aws-sdk-greengrass 0.21.0

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateThingRuntimeConfigurationOutput {}
impl std::fmt::Debug for UpdateThingRuntimeConfigurationOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateThingRuntimeConfigurationOutput");
        formatter.finish()
    }
}
/// See [`UpdateThingRuntimeConfigurationOutput`](crate::output::UpdateThingRuntimeConfigurationOutput).
pub mod update_thing_runtime_configuration_output {

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

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

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

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

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

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

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateGroupCertificateConfigurationOutput {
    /// The amount of time remaining before the certificate authority expires, in milliseconds.
    #[doc(hidden)]
    pub certificate_authority_expiry_in_milliseconds: std::option::Option<std::string::String>,
    /// The amount of time remaining before the certificate expires, in milliseconds.
    #[doc(hidden)]
    pub certificate_expiry_in_milliseconds: std::option::Option<std::string::String>,
    /// The ID of the group certificate configuration.
    #[doc(hidden)]
    pub group_id: std::option::Option<std::string::String>,
}
impl UpdateGroupCertificateConfigurationOutput {
    /// The amount of time remaining before the certificate authority expires, in milliseconds.
    pub fn certificate_authority_expiry_in_milliseconds(&self) -> std::option::Option<&str> {
        self.certificate_authority_expiry_in_milliseconds.as_deref()
    }
    /// The amount of time remaining before the certificate expires, in milliseconds.
    pub fn certificate_expiry_in_milliseconds(&self) -> std::option::Option<&str> {
        self.certificate_expiry_in_milliseconds.as_deref()
    }
    /// The ID of the group certificate configuration.
    pub fn group_id(&self) -> std::option::Option<&str> {
        self.group_id.as_deref()
    }
}
impl std::fmt::Debug for UpdateGroupCertificateConfigurationOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateGroupCertificateConfigurationOutput");
        formatter.field(
            "certificate_authority_expiry_in_milliseconds",
            &self.certificate_authority_expiry_in_milliseconds,
        );
        formatter.field(
            "certificate_expiry_in_milliseconds",
            &self.certificate_expiry_in_milliseconds,
        );
        formatter.field("group_id", &self.group_id);
        formatter.finish()
    }
}
/// See [`UpdateGroupCertificateConfigurationOutput`](crate::output::UpdateGroupCertificateConfigurationOutput).
pub mod update_group_certificate_configuration_output {

    /// A builder for [`UpdateGroupCertificateConfigurationOutput`](crate::output::UpdateGroupCertificateConfigurationOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) certificate_authority_expiry_in_milliseconds:
            std::option::Option<std::string::String>,
        pub(crate) certificate_expiry_in_milliseconds: std::option::Option<std::string::String>,
        pub(crate) group_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The amount of time remaining before the certificate authority expires, in milliseconds.
        pub fn certificate_authority_expiry_in_milliseconds(
            mut self,
            input: impl Into<std::string::String>,
        ) -> Self {
            self.certificate_authority_expiry_in_milliseconds = Some(input.into());
            self
        }
        /// The amount of time remaining before the certificate authority expires, in milliseconds.
        pub fn set_certificate_authority_expiry_in_milliseconds(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.certificate_authority_expiry_in_milliseconds = input;
            self
        }
        /// The amount of time remaining before the certificate expires, in milliseconds.
        pub fn certificate_expiry_in_milliseconds(
            mut self,
            input: impl Into<std::string::String>,
        ) -> Self {
            self.certificate_expiry_in_milliseconds = Some(input.into());
            self
        }
        /// The amount of time remaining before the certificate expires, in milliseconds.
        pub fn set_certificate_expiry_in_milliseconds(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.certificate_expiry_in_milliseconds = input;
            self
        }
        /// The ID of the group certificate configuration.
        pub fn group_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.group_id = Some(input.into());
            self
        }
        /// The ID of the group certificate configuration.
        pub fn set_group_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.group_id = input;
            self
        }
        /// Consumes the builder and constructs a [`UpdateGroupCertificateConfigurationOutput`](crate::output::UpdateGroupCertificateConfigurationOutput).
        pub fn build(self) -> crate::output::UpdateGroupCertificateConfigurationOutput {
            crate::output::UpdateGroupCertificateConfigurationOutput {
                certificate_authority_expiry_in_milliseconds: self
                    .certificate_authority_expiry_in_milliseconds,
                certificate_expiry_in_milliseconds: self.certificate_expiry_in_milliseconds,
                group_id: self.group_id,
            }
        }
    }
}
impl UpdateGroupCertificateConfigurationOutput {
    /// Creates a new builder-style object to manufacture [`UpdateGroupCertificateConfigurationOutput`](crate::output::UpdateGroupCertificateConfigurationOutput).
    pub fn builder() -> crate::output::update_group_certificate_configuration_output::Builder {
        crate::output::update_group_certificate_configuration_output::Builder::default()
    }
}

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

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

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

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

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

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

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

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

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

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateConnectivityInfoOutput {
    /// A message about the connectivity info update request.
    #[doc(hidden)]
    pub message: std::option::Option<std::string::String>,
    /// The new version of the connectivity info.
    #[doc(hidden)]
    pub version: std::option::Option<std::string::String>,
}
impl UpdateConnectivityInfoOutput {
    /// A message about the connectivity info update request.
    pub fn message(&self) -> std::option::Option<&str> {
        self.message.as_deref()
    }
    /// The new version of the connectivity info.
    pub fn version(&self) -> std::option::Option<&str> {
        self.version.as_deref()
    }
}
impl std::fmt::Debug for UpdateConnectivityInfoOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateConnectivityInfoOutput");
        formatter.field("message", &self.message);
        formatter.field("version", &self.version);
        formatter.finish()
    }
}
/// See [`UpdateConnectivityInfoOutput`](crate::output::UpdateConnectivityInfoOutput).
pub mod update_connectivity_info_output {

    /// A builder for [`UpdateConnectivityInfoOutput`](crate::output::UpdateConnectivityInfoOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) message: std::option::Option<std::string::String>,
        pub(crate) version: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// A message about the connectivity info update request.
        pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
            self.message = Some(input.into());
            self
        }
        /// A message about the connectivity info update request.
        pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.message = input;
            self
        }
        /// The new version of the connectivity info.
        pub fn version(mut self, input: impl Into<std::string::String>) -> Self {
            self.version = Some(input.into());
            self
        }
        /// The new version of the connectivity info.
        pub fn set_version(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.version = input;
            self
        }
        /// Consumes the builder and constructs a [`UpdateConnectivityInfoOutput`](crate::output::UpdateConnectivityInfoOutput).
        pub fn build(self) -> crate::output::UpdateConnectivityInfoOutput {
            crate::output::UpdateConnectivityInfoOutput {
                message: self.message,
                version: self.version,
            }
        }
    }
}
impl UpdateConnectivityInfoOutput {
    /// Creates a new builder-style object to manufacture [`UpdateConnectivityInfoOutput`](crate::output::UpdateConnectivityInfoOutput).
    pub fn builder() -> crate::output::update_connectivity_info_output::Builder {
        crate::output::update_connectivity_info_output::Builder::default()
    }
}

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

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

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

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

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

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct StartBulkDeploymentOutput {
    /// The ARN of the bulk deployment.
    #[doc(hidden)]
    pub bulk_deployment_arn: std::option::Option<std::string::String>,
    /// The ID of the bulk deployment.
    #[doc(hidden)]
    pub bulk_deployment_id: std::option::Option<std::string::String>,
}
impl StartBulkDeploymentOutput {
    /// The ARN of the bulk deployment.
    pub fn bulk_deployment_arn(&self) -> std::option::Option<&str> {
        self.bulk_deployment_arn.as_deref()
    }
    /// The ID of the bulk deployment.
    pub fn bulk_deployment_id(&self) -> std::option::Option<&str> {
        self.bulk_deployment_id.as_deref()
    }
}
impl std::fmt::Debug for StartBulkDeploymentOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("StartBulkDeploymentOutput");
        formatter.field("bulk_deployment_arn", &self.bulk_deployment_arn);
        formatter.field("bulk_deployment_id", &self.bulk_deployment_id);
        formatter.finish()
    }
}
/// See [`StartBulkDeploymentOutput`](crate::output::StartBulkDeploymentOutput).
pub mod start_bulk_deployment_output {

    /// A builder for [`StartBulkDeploymentOutput`](crate::output::StartBulkDeploymentOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) bulk_deployment_arn: std::option::Option<std::string::String>,
        pub(crate) bulk_deployment_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The ARN of the bulk deployment.
        pub fn bulk_deployment_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.bulk_deployment_arn = Some(input.into());
            self
        }
        /// The ARN of the bulk deployment.
        pub fn set_bulk_deployment_arn(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.bulk_deployment_arn = input;
            self
        }
        /// The ID of the bulk deployment.
        pub fn bulk_deployment_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.bulk_deployment_id = Some(input.into());
            self
        }
        /// The ID of the bulk deployment.
        pub fn set_bulk_deployment_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.bulk_deployment_id = input;
            self
        }
        /// Consumes the builder and constructs a [`StartBulkDeploymentOutput`](crate::output::StartBulkDeploymentOutput).
        pub fn build(self) -> crate::output::StartBulkDeploymentOutput {
            crate::output::StartBulkDeploymentOutput {
                bulk_deployment_arn: self.bulk_deployment_arn,
                bulk_deployment_id: self.bulk_deployment_id,
            }
        }
    }
}
impl StartBulkDeploymentOutput {
    /// Creates a new builder-style object to manufacture [`StartBulkDeploymentOutput`](crate::output::StartBulkDeploymentOutput).
    pub fn builder() -> crate::output::start_bulk_deployment_output::Builder {
        crate::output::start_bulk_deployment_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ResetDeploymentsOutput {
    /// The ARN of the deployment.
    #[doc(hidden)]
    pub deployment_arn: std::option::Option<std::string::String>,
    /// The ID of the deployment.
    #[doc(hidden)]
    pub deployment_id: std::option::Option<std::string::String>,
}
impl ResetDeploymentsOutput {
    /// The ARN of the deployment.
    pub fn deployment_arn(&self) -> std::option::Option<&str> {
        self.deployment_arn.as_deref()
    }
    /// The ID of the deployment.
    pub fn deployment_id(&self) -> std::option::Option<&str> {
        self.deployment_id.as_deref()
    }
}
impl std::fmt::Debug for ResetDeploymentsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ResetDeploymentsOutput");
        formatter.field("deployment_arn", &self.deployment_arn);
        formatter.field("deployment_id", &self.deployment_id);
        formatter.finish()
    }
}
/// See [`ResetDeploymentsOutput`](crate::output::ResetDeploymentsOutput).
pub mod reset_deployments_output {

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListTagsForResourceOutput {
    /// The key-value pair for the resource tag.
    #[doc(hidden)]
    pub tags:
        std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl ListTagsForResourceOutput {
    /// The key-value pair for the resource tag.
    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).
    #[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).
        ///
        /// The key-value pair for the resource tag.
        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
        }
        /// The key-value pair for the resource tag.
        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 ListSubscriptionDefinitionVersionsOutput {
    /// The token for the next set of results, or ''null'' if there are no additional results.
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
    /// Information about a version.
    #[doc(hidden)]
    pub versions: std::option::Option<std::vec::Vec<crate::model::VersionInformation>>,
}
impl ListSubscriptionDefinitionVersionsOutput {
    /// The token for the next set of results, or ''null'' if there are no additional results.
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// Information about a version.
    pub fn versions(&self) -> std::option::Option<&[crate::model::VersionInformation]> {
        self.versions.as_deref()
    }
}
impl std::fmt::Debug for ListSubscriptionDefinitionVersionsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListSubscriptionDefinitionVersionsOutput");
        formatter.field("next_token", &self.next_token);
        formatter.field("versions", &self.versions);
        formatter.finish()
    }
}
/// See [`ListSubscriptionDefinitionVersionsOutput`](crate::output::ListSubscriptionDefinitionVersionsOutput).
pub mod list_subscription_definition_versions_output {

    /// A builder for [`ListSubscriptionDefinitionVersionsOutput`](crate::output::ListSubscriptionDefinitionVersionsOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) versions: std::option::Option<std::vec::Vec<crate::model::VersionInformation>>,
    }
    impl Builder {
        /// The token for the next set of results, or ''null'' if there are no additional results.
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// The token for the next set of results, or ''null'' if there are no additional results.
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Appends an item to `versions`.
        ///
        /// To override the contents of this collection use [`set_versions`](Self::set_versions).
        ///
        /// Information about a version.
        pub fn versions(mut self, input: crate::model::VersionInformation) -> Self {
            let mut v = self.versions.unwrap_or_default();
            v.push(input);
            self.versions = Some(v);
            self
        }
        /// Information about a version.
        pub fn set_versions(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::VersionInformation>>,
        ) -> Self {
            self.versions = input;
            self
        }
        /// Consumes the builder and constructs a [`ListSubscriptionDefinitionVersionsOutput`](crate::output::ListSubscriptionDefinitionVersionsOutput).
        pub fn build(self) -> crate::output::ListSubscriptionDefinitionVersionsOutput {
            crate::output::ListSubscriptionDefinitionVersionsOutput {
                next_token: self.next_token,
                versions: self.versions,
            }
        }
    }
}
impl ListSubscriptionDefinitionVersionsOutput {
    /// Creates a new builder-style object to manufacture [`ListSubscriptionDefinitionVersionsOutput`](crate::output::ListSubscriptionDefinitionVersionsOutput).
    pub fn builder() -> crate::output::list_subscription_definition_versions_output::Builder {
        crate::output::list_subscription_definition_versions_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListSubscriptionDefinitionsOutput {
    /// Information about a definition.
    #[doc(hidden)]
    pub definitions: std::option::Option<std::vec::Vec<crate::model::DefinitionInformation>>,
    /// The token for the next set of results, or ''null'' if there are no additional results.
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
}
impl ListSubscriptionDefinitionsOutput {
    /// Information about a definition.
    pub fn definitions(&self) -> std::option::Option<&[crate::model::DefinitionInformation]> {
        self.definitions.as_deref()
    }
    /// The token for the next set of results, or ''null'' if there are no additional results.
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListSubscriptionDefinitionsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListSubscriptionDefinitionsOutput");
        formatter.field("definitions", &self.definitions);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListSubscriptionDefinitionsOutput`](crate::output::ListSubscriptionDefinitionsOutput).
pub mod list_subscription_definitions_output {

    /// A builder for [`ListSubscriptionDefinitionsOutput`](crate::output::ListSubscriptionDefinitionsOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) definitions:
            std::option::Option<std::vec::Vec<crate::model::DefinitionInformation>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `definitions`.
        ///
        /// To override the contents of this collection use [`set_definitions`](Self::set_definitions).
        ///
        /// Information about a definition.
        pub fn definitions(mut self, input: crate::model::DefinitionInformation) -> Self {
            let mut v = self.definitions.unwrap_or_default();
            v.push(input);
            self.definitions = Some(v);
            self
        }
        /// Information about a definition.
        pub fn set_definitions(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::DefinitionInformation>>,
        ) -> Self {
            self.definitions = input;
            self
        }
        /// The token for the next set of results, or ''null'' if there are no additional results.
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// The token for the next set of results, or ''null'' if there are no additional results.
        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 [`ListSubscriptionDefinitionsOutput`](crate::output::ListSubscriptionDefinitionsOutput).
        pub fn build(self) -> crate::output::ListSubscriptionDefinitionsOutput {
            crate::output::ListSubscriptionDefinitionsOutput {
                definitions: self.definitions,
                next_token: self.next_token,
            }
        }
    }
}
impl ListSubscriptionDefinitionsOutput {
    /// Creates a new builder-style object to manufacture [`ListSubscriptionDefinitionsOutput`](crate::output::ListSubscriptionDefinitionsOutput).
    pub fn builder() -> crate::output::list_subscription_definitions_output::Builder {
        crate::output::list_subscription_definitions_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListResourceDefinitionVersionsOutput {
    /// The token for the next set of results, or ''null'' if there are no additional results.
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
    /// Information about a version.
    #[doc(hidden)]
    pub versions: std::option::Option<std::vec::Vec<crate::model::VersionInformation>>,
}
impl ListResourceDefinitionVersionsOutput {
    /// The token for the next set of results, or ''null'' if there are no additional results.
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// Information about a version.
    pub fn versions(&self) -> std::option::Option<&[crate::model::VersionInformation]> {
        self.versions.as_deref()
    }
}
impl std::fmt::Debug for ListResourceDefinitionVersionsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListResourceDefinitionVersionsOutput");
        formatter.field("next_token", &self.next_token);
        formatter.field("versions", &self.versions);
        formatter.finish()
    }
}
/// See [`ListResourceDefinitionVersionsOutput`](crate::output::ListResourceDefinitionVersionsOutput).
pub mod list_resource_definition_versions_output {

    /// A builder for [`ListResourceDefinitionVersionsOutput`](crate::output::ListResourceDefinitionVersionsOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) versions: std::option::Option<std::vec::Vec<crate::model::VersionInformation>>,
    }
    impl Builder {
        /// The token for the next set of results, or ''null'' if there are no additional results.
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// The token for the next set of results, or ''null'' if there are no additional results.
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Appends an item to `versions`.
        ///
        /// To override the contents of this collection use [`set_versions`](Self::set_versions).
        ///
        /// Information about a version.
        pub fn versions(mut self, input: crate::model::VersionInformation) -> Self {
            let mut v = self.versions.unwrap_or_default();
            v.push(input);
            self.versions = Some(v);
            self
        }
        /// Information about a version.
        pub fn set_versions(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::VersionInformation>>,
        ) -> Self {
            self.versions = input;
            self
        }
        /// Consumes the builder and constructs a [`ListResourceDefinitionVersionsOutput`](crate::output::ListResourceDefinitionVersionsOutput).
        pub fn build(self) -> crate::output::ListResourceDefinitionVersionsOutput {
            crate::output::ListResourceDefinitionVersionsOutput {
                next_token: self.next_token,
                versions: self.versions,
            }
        }
    }
}
impl ListResourceDefinitionVersionsOutput {
    /// Creates a new builder-style object to manufacture [`ListResourceDefinitionVersionsOutput`](crate::output::ListResourceDefinitionVersionsOutput).
    pub fn builder() -> crate::output::list_resource_definition_versions_output::Builder {
        crate::output::list_resource_definition_versions_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListResourceDefinitionsOutput {
    /// Information about a definition.
    #[doc(hidden)]
    pub definitions: std::option::Option<std::vec::Vec<crate::model::DefinitionInformation>>,
    /// The token for the next set of results, or ''null'' if there are no additional results.
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
}
impl ListResourceDefinitionsOutput {
    /// Information about a definition.
    pub fn definitions(&self) -> std::option::Option<&[crate::model::DefinitionInformation]> {
        self.definitions.as_deref()
    }
    /// The token for the next set of results, or ''null'' if there are no additional results.
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListResourceDefinitionsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListResourceDefinitionsOutput");
        formatter.field("definitions", &self.definitions);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListResourceDefinitionsOutput`](crate::output::ListResourceDefinitionsOutput).
pub mod list_resource_definitions_output {

    /// A builder for [`ListResourceDefinitionsOutput`](crate::output::ListResourceDefinitionsOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) definitions:
            std::option::Option<std::vec::Vec<crate::model::DefinitionInformation>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `definitions`.
        ///
        /// To override the contents of this collection use [`set_definitions`](Self::set_definitions).
        ///
        /// Information about a definition.
        pub fn definitions(mut self, input: crate::model::DefinitionInformation) -> Self {
            let mut v = self.definitions.unwrap_or_default();
            v.push(input);
            self.definitions = Some(v);
            self
        }
        /// Information about a definition.
        pub fn set_definitions(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::DefinitionInformation>>,
        ) -> Self {
            self.definitions = input;
            self
        }
        /// The token for the next set of results, or ''null'' if there are no additional results.
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// The token for the next set of results, or ''null'' if there are no additional results.
        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 [`ListResourceDefinitionsOutput`](crate::output::ListResourceDefinitionsOutput).
        pub fn build(self) -> crate::output::ListResourceDefinitionsOutput {
            crate::output::ListResourceDefinitionsOutput {
                definitions: self.definitions,
                next_token: self.next_token,
            }
        }
    }
}
impl ListResourceDefinitionsOutput {
    /// Creates a new builder-style object to manufacture [`ListResourceDefinitionsOutput`](crate::output::ListResourceDefinitionsOutput).
    pub fn builder() -> crate::output::list_resource_definitions_output::Builder {
        crate::output::list_resource_definitions_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListLoggerDefinitionVersionsOutput {
    /// The token for the next set of results, or ''null'' if there are no additional results.
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
    /// Information about a version.
    #[doc(hidden)]
    pub versions: std::option::Option<std::vec::Vec<crate::model::VersionInformation>>,
}
impl ListLoggerDefinitionVersionsOutput {
    /// The token for the next set of results, or ''null'' if there are no additional results.
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// Information about a version.
    pub fn versions(&self) -> std::option::Option<&[crate::model::VersionInformation]> {
        self.versions.as_deref()
    }
}
impl std::fmt::Debug for ListLoggerDefinitionVersionsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListLoggerDefinitionVersionsOutput");
        formatter.field("next_token", &self.next_token);
        formatter.field("versions", &self.versions);
        formatter.finish()
    }
}
/// See [`ListLoggerDefinitionVersionsOutput`](crate::output::ListLoggerDefinitionVersionsOutput).
pub mod list_logger_definition_versions_output {

    /// A builder for [`ListLoggerDefinitionVersionsOutput`](crate::output::ListLoggerDefinitionVersionsOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) versions: std::option::Option<std::vec::Vec<crate::model::VersionInformation>>,
    }
    impl Builder {
        /// The token for the next set of results, or ''null'' if there are no additional results.
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// The token for the next set of results, or ''null'' if there are no additional results.
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Appends an item to `versions`.
        ///
        /// To override the contents of this collection use [`set_versions`](Self::set_versions).
        ///
        /// Information about a version.
        pub fn versions(mut self, input: crate::model::VersionInformation) -> Self {
            let mut v = self.versions.unwrap_or_default();
            v.push(input);
            self.versions = Some(v);
            self
        }
        /// Information about a version.
        pub fn set_versions(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::VersionInformation>>,
        ) -> Self {
            self.versions = input;
            self
        }
        /// Consumes the builder and constructs a [`ListLoggerDefinitionVersionsOutput`](crate::output::ListLoggerDefinitionVersionsOutput).
        pub fn build(self) -> crate::output::ListLoggerDefinitionVersionsOutput {
            crate::output::ListLoggerDefinitionVersionsOutput {
                next_token: self.next_token,
                versions: self.versions,
            }
        }
    }
}
impl ListLoggerDefinitionVersionsOutput {
    /// Creates a new builder-style object to manufacture [`ListLoggerDefinitionVersionsOutput`](crate::output::ListLoggerDefinitionVersionsOutput).
    pub fn builder() -> crate::output::list_logger_definition_versions_output::Builder {
        crate::output::list_logger_definition_versions_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListLoggerDefinitionsOutput {
    /// Information about a definition.
    #[doc(hidden)]
    pub definitions: std::option::Option<std::vec::Vec<crate::model::DefinitionInformation>>,
    /// The token for the next set of results, or ''null'' if there are no additional results.
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
}
impl ListLoggerDefinitionsOutput {
    /// Information about a definition.
    pub fn definitions(&self) -> std::option::Option<&[crate::model::DefinitionInformation]> {
        self.definitions.as_deref()
    }
    /// The token for the next set of results, or ''null'' if there are no additional results.
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListLoggerDefinitionsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListLoggerDefinitionsOutput");
        formatter.field("definitions", &self.definitions);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListLoggerDefinitionsOutput`](crate::output::ListLoggerDefinitionsOutput).
pub mod list_logger_definitions_output {

    /// A builder for [`ListLoggerDefinitionsOutput`](crate::output::ListLoggerDefinitionsOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) definitions:
            std::option::Option<std::vec::Vec<crate::model::DefinitionInformation>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `definitions`.
        ///
        /// To override the contents of this collection use [`set_definitions`](Self::set_definitions).
        ///
        /// Information about a definition.
        pub fn definitions(mut self, input: crate::model::DefinitionInformation) -> Self {
            let mut v = self.definitions.unwrap_or_default();
            v.push(input);
            self.definitions = Some(v);
            self
        }
        /// Information about a definition.
        pub fn set_definitions(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::DefinitionInformation>>,
        ) -> Self {
            self.definitions = input;
            self
        }
        /// The token for the next set of results, or ''null'' if there are no additional results.
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// The token for the next set of results, or ''null'' if there are no additional results.
        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 [`ListLoggerDefinitionsOutput`](crate::output::ListLoggerDefinitionsOutput).
        pub fn build(self) -> crate::output::ListLoggerDefinitionsOutput {
            crate::output::ListLoggerDefinitionsOutput {
                definitions: self.definitions,
                next_token: self.next_token,
            }
        }
    }
}
impl ListLoggerDefinitionsOutput {
    /// Creates a new builder-style object to manufacture [`ListLoggerDefinitionsOutput`](crate::output::ListLoggerDefinitionsOutput).
    pub fn builder() -> crate::output::list_logger_definitions_output::Builder {
        crate::output::list_logger_definitions_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListGroupVersionsOutput {
    /// The token for the next set of results, or ''null'' if there are no additional results.
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
    /// Information about a version.
    #[doc(hidden)]
    pub versions: std::option::Option<std::vec::Vec<crate::model::VersionInformation>>,
}
impl ListGroupVersionsOutput {
    /// The token for the next set of results, or ''null'' if there are no additional results.
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// Information about a version.
    pub fn versions(&self) -> std::option::Option<&[crate::model::VersionInformation]> {
        self.versions.as_deref()
    }
}
impl std::fmt::Debug for ListGroupVersionsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListGroupVersionsOutput");
        formatter.field("next_token", &self.next_token);
        formatter.field("versions", &self.versions);
        formatter.finish()
    }
}
/// See [`ListGroupVersionsOutput`](crate::output::ListGroupVersionsOutput).
pub mod list_group_versions_output {

    /// A builder for [`ListGroupVersionsOutput`](crate::output::ListGroupVersionsOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) versions: std::option::Option<std::vec::Vec<crate::model::VersionInformation>>,
    }
    impl Builder {
        /// The token for the next set of results, or ''null'' if there are no additional results.
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// The token for the next set of results, or ''null'' if there are no additional results.
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Appends an item to `versions`.
        ///
        /// To override the contents of this collection use [`set_versions`](Self::set_versions).
        ///
        /// Information about a version.
        pub fn versions(mut self, input: crate::model::VersionInformation) -> Self {
            let mut v = self.versions.unwrap_or_default();
            v.push(input);
            self.versions = Some(v);
            self
        }
        /// Information about a version.
        pub fn set_versions(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::VersionInformation>>,
        ) -> Self {
            self.versions = input;
            self
        }
        /// Consumes the builder and constructs a [`ListGroupVersionsOutput`](crate::output::ListGroupVersionsOutput).
        pub fn build(self) -> crate::output::ListGroupVersionsOutput {
            crate::output::ListGroupVersionsOutput {
                next_token: self.next_token,
                versions: self.versions,
            }
        }
    }
}
impl ListGroupVersionsOutput {
    /// Creates a new builder-style object to manufacture [`ListGroupVersionsOutput`](crate::output::ListGroupVersionsOutput).
    pub fn builder() -> crate::output::list_group_versions_output::Builder {
        crate::output::list_group_versions_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListGroupsOutput {
    /// Information about a group.
    #[doc(hidden)]
    pub groups: std::option::Option<std::vec::Vec<crate::model::GroupInformation>>,
    /// The token for the next set of results, or ''null'' if there are no additional results.
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
}
impl ListGroupsOutput {
    /// Information about a group.
    pub fn groups(&self) -> std::option::Option<&[crate::model::GroupInformation]> {
        self.groups.as_deref()
    }
    /// The token for the next set of results, or ''null'' if there are no additional results.
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListGroupsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListGroupsOutput");
        formatter.field("groups", &self.groups);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListGroupsOutput`](crate::output::ListGroupsOutput).
pub mod list_groups_output {

    /// A builder for [`ListGroupsOutput`](crate::output::ListGroupsOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) groups: std::option::Option<std::vec::Vec<crate::model::GroupInformation>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `groups`.
        ///
        /// To override the contents of this collection use [`set_groups`](Self::set_groups).
        ///
        /// Information about a group.
        pub fn groups(mut self, input: crate::model::GroupInformation) -> Self {
            let mut v = self.groups.unwrap_or_default();
            v.push(input);
            self.groups = Some(v);
            self
        }
        /// Information about a group.
        pub fn set_groups(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::GroupInformation>>,
        ) -> Self {
            self.groups = input;
            self
        }
        /// The token for the next set of results, or ''null'' if there are no additional results.
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// The token for the next set of results, or ''null'' if there are no additional results.
        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 [`ListGroupsOutput`](crate::output::ListGroupsOutput).
        pub fn build(self) -> crate::output::ListGroupsOutput {
            crate::output::ListGroupsOutput {
                groups: self.groups,
                next_token: self.next_token,
            }
        }
    }
}
impl ListGroupsOutput {
    /// Creates a new builder-style object to manufacture [`ListGroupsOutput`](crate::output::ListGroupsOutput).
    pub fn builder() -> crate::output::list_groups_output::Builder {
        crate::output::list_groups_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListGroupCertificateAuthoritiesOutput {
    /// A list of certificate authorities associated with the group.
    #[doc(hidden)]
    pub group_certificate_authorities:
        std::option::Option<std::vec::Vec<crate::model::GroupCertificateAuthorityProperties>>,
}
impl ListGroupCertificateAuthoritiesOutput {
    /// A list of certificate authorities associated with the group.
    pub fn group_certificate_authorities(
        &self,
    ) -> std::option::Option<&[crate::model::GroupCertificateAuthorityProperties]> {
        self.group_certificate_authorities.as_deref()
    }
}
impl std::fmt::Debug for ListGroupCertificateAuthoritiesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListGroupCertificateAuthoritiesOutput");
        formatter.field(
            "group_certificate_authorities",
            &self.group_certificate_authorities,
        );
        formatter.finish()
    }
}
/// See [`ListGroupCertificateAuthoritiesOutput`](crate::output::ListGroupCertificateAuthoritiesOutput).
pub mod list_group_certificate_authorities_output {

    /// A builder for [`ListGroupCertificateAuthoritiesOutput`](crate::output::ListGroupCertificateAuthoritiesOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) group_certificate_authorities:
            std::option::Option<std::vec::Vec<crate::model::GroupCertificateAuthorityProperties>>,
    }
    impl Builder {
        /// Appends an item to `group_certificate_authorities`.
        ///
        /// To override the contents of this collection use [`set_group_certificate_authorities`](Self::set_group_certificate_authorities).
        ///
        /// A list of certificate authorities associated with the group.
        pub fn group_certificate_authorities(
            mut self,
            input: crate::model::GroupCertificateAuthorityProperties,
        ) -> Self {
            let mut v = self.group_certificate_authorities.unwrap_or_default();
            v.push(input);
            self.group_certificate_authorities = Some(v);
            self
        }
        /// A list of certificate authorities associated with the group.
        pub fn set_group_certificate_authorities(
            mut self,
            input: std::option::Option<
                std::vec::Vec<crate::model::GroupCertificateAuthorityProperties>,
            >,
        ) -> Self {
            self.group_certificate_authorities = input;
            self
        }
        /// Consumes the builder and constructs a [`ListGroupCertificateAuthoritiesOutput`](crate::output::ListGroupCertificateAuthoritiesOutput).
        pub fn build(self) -> crate::output::ListGroupCertificateAuthoritiesOutput {
            crate::output::ListGroupCertificateAuthoritiesOutput {
                group_certificate_authorities: self.group_certificate_authorities,
            }
        }
    }
}
impl ListGroupCertificateAuthoritiesOutput {
    /// Creates a new builder-style object to manufacture [`ListGroupCertificateAuthoritiesOutput`](crate::output::ListGroupCertificateAuthoritiesOutput).
    pub fn builder() -> crate::output::list_group_certificate_authorities_output::Builder {
        crate::output::list_group_certificate_authorities_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListFunctionDefinitionVersionsOutput {
    /// The token for the next set of results, or ''null'' if there are no additional results.
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
    /// Information about a version.
    #[doc(hidden)]
    pub versions: std::option::Option<std::vec::Vec<crate::model::VersionInformation>>,
}
impl ListFunctionDefinitionVersionsOutput {
    /// The token for the next set of results, or ''null'' if there are no additional results.
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// Information about a version.
    pub fn versions(&self) -> std::option::Option<&[crate::model::VersionInformation]> {
        self.versions.as_deref()
    }
}
impl std::fmt::Debug for ListFunctionDefinitionVersionsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListFunctionDefinitionVersionsOutput");
        formatter.field("next_token", &self.next_token);
        formatter.field("versions", &self.versions);
        formatter.finish()
    }
}
/// See [`ListFunctionDefinitionVersionsOutput`](crate::output::ListFunctionDefinitionVersionsOutput).
pub mod list_function_definition_versions_output {

    /// A builder for [`ListFunctionDefinitionVersionsOutput`](crate::output::ListFunctionDefinitionVersionsOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) versions: std::option::Option<std::vec::Vec<crate::model::VersionInformation>>,
    }
    impl Builder {
        /// The token for the next set of results, or ''null'' if there are no additional results.
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// The token for the next set of results, or ''null'' if there are no additional results.
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Appends an item to `versions`.
        ///
        /// To override the contents of this collection use [`set_versions`](Self::set_versions).
        ///
        /// Information about a version.
        pub fn versions(mut self, input: crate::model::VersionInformation) -> Self {
            let mut v = self.versions.unwrap_or_default();
            v.push(input);
            self.versions = Some(v);
            self
        }
        /// Information about a version.
        pub fn set_versions(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::VersionInformation>>,
        ) -> Self {
            self.versions = input;
            self
        }
        /// Consumes the builder and constructs a [`ListFunctionDefinitionVersionsOutput`](crate::output::ListFunctionDefinitionVersionsOutput).
        pub fn build(self) -> crate::output::ListFunctionDefinitionVersionsOutput {
            crate::output::ListFunctionDefinitionVersionsOutput {
                next_token: self.next_token,
                versions: self.versions,
            }
        }
    }
}
impl ListFunctionDefinitionVersionsOutput {
    /// Creates a new builder-style object to manufacture [`ListFunctionDefinitionVersionsOutput`](crate::output::ListFunctionDefinitionVersionsOutput).
    pub fn builder() -> crate::output::list_function_definition_versions_output::Builder {
        crate::output::list_function_definition_versions_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListFunctionDefinitionsOutput {
    /// Information about a definition.
    #[doc(hidden)]
    pub definitions: std::option::Option<std::vec::Vec<crate::model::DefinitionInformation>>,
    /// The token for the next set of results, or ''null'' if there are no additional results.
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
}
impl ListFunctionDefinitionsOutput {
    /// Information about a definition.
    pub fn definitions(&self) -> std::option::Option<&[crate::model::DefinitionInformation]> {
        self.definitions.as_deref()
    }
    /// The token for the next set of results, or ''null'' if there are no additional results.
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListFunctionDefinitionsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListFunctionDefinitionsOutput");
        formatter.field("definitions", &self.definitions);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListFunctionDefinitionsOutput`](crate::output::ListFunctionDefinitionsOutput).
pub mod list_function_definitions_output {

    /// A builder for [`ListFunctionDefinitionsOutput`](crate::output::ListFunctionDefinitionsOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) definitions:
            std::option::Option<std::vec::Vec<crate::model::DefinitionInformation>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `definitions`.
        ///
        /// To override the contents of this collection use [`set_definitions`](Self::set_definitions).
        ///
        /// Information about a definition.
        pub fn definitions(mut self, input: crate::model::DefinitionInformation) -> Self {
            let mut v = self.definitions.unwrap_or_default();
            v.push(input);
            self.definitions = Some(v);
            self
        }
        /// Information about a definition.
        pub fn set_definitions(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::DefinitionInformation>>,
        ) -> Self {
            self.definitions = input;
            self
        }
        /// The token for the next set of results, or ''null'' if there are no additional results.
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// The token for the next set of results, or ''null'' if there are no additional results.
        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 [`ListFunctionDefinitionsOutput`](crate::output::ListFunctionDefinitionsOutput).
        pub fn build(self) -> crate::output::ListFunctionDefinitionsOutput {
            crate::output::ListFunctionDefinitionsOutput {
                definitions: self.definitions,
                next_token: self.next_token,
            }
        }
    }
}
impl ListFunctionDefinitionsOutput {
    /// Creates a new builder-style object to manufacture [`ListFunctionDefinitionsOutput`](crate::output::ListFunctionDefinitionsOutput).
    pub fn builder() -> crate::output::list_function_definitions_output::Builder {
        crate::output::list_function_definitions_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListDeviceDefinitionVersionsOutput {
    /// The token for the next set of results, or ''null'' if there are no additional results.
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
    /// Information about a version.
    #[doc(hidden)]
    pub versions: std::option::Option<std::vec::Vec<crate::model::VersionInformation>>,
}
impl ListDeviceDefinitionVersionsOutput {
    /// The token for the next set of results, or ''null'' if there are no additional results.
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// Information about a version.
    pub fn versions(&self) -> std::option::Option<&[crate::model::VersionInformation]> {
        self.versions.as_deref()
    }
}
impl std::fmt::Debug for ListDeviceDefinitionVersionsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListDeviceDefinitionVersionsOutput");
        formatter.field("next_token", &self.next_token);
        formatter.field("versions", &self.versions);
        formatter.finish()
    }
}
/// See [`ListDeviceDefinitionVersionsOutput`](crate::output::ListDeviceDefinitionVersionsOutput).
pub mod list_device_definition_versions_output {

    /// A builder for [`ListDeviceDefinitionVersionsOutput`](crate::output::ListDeviceDefinitionVersionsOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) versions: std::option::Option<std::vec::Vec<crate::model::VersionInformation>>,
    }
    impl Builder {
        /// The token for the next set of results, or ''null'' if there are no additional results.
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// The token for the next set of results, or ''null'' if there are no additional results.
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Appends an item to `versions`.
        ///
        /// To override the contents of this collection use [`set_versions`](Self::set_versions).
        ///
        /// Information about a version.
        pub fn versions(mut self, input: crate::model::VersionInformation) -> Self {
            let mut v = self.versions.unwrap_or_default();
            v.push(input);
            self.versions = Some(v);
            self
        }
        /// Information about a version.
        pub fn set_versions(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::VersionInformation>>,
        ) -> Self {
            self.versions = input;
            self
        }
        /// Consumes the builder and constructs a [`ListDeviceDefinitionVersionsOutput`](crate::output::ListDeviceDefinitionVersionsOutput).
        pub fn build(self) -> crate::output::ListDeviceDefinitionVersionsOutput {
            crate::output::ListDeviceDefinitionVersionsOutput {
                next_token: self.next_token,
                versions: self.versions,
            }
        }
    }
}
impl ListDeviceDefinitionVersionsOutput {
    /// Creates a new builder-style object to manufacture [`ListDeviceDefinitionVersionsOutput`](crate::output::ListDeviceDefinitionVersionsOutput).
    pub fn builder() -> crate::output::list_device_definition_versions_output::Builder {
        crate::output::list_device_definition_versions_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListDeviceDefinitionsOutput {
    /// Information about a definition.
    #[doc(hidden)]
    pub definitions: std::option::Option<std::vec::Vec<crate::model::DefinitionInformation>>,
    /// The token for the next set of results, or ''null'' if there are no additional results.
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
}
impl ListDeviceDefinitionsOutput {
    /// Information about a definition.
    pub fn definitions(&self) -> std::option::Option<&[crate::model::DefinitionInformation]> {
        self.definitions.as_deref()
    }
    /// The token for the next set of results, or ''null'' if there are no additional results.
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListDeviceDefinitionsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListDeviceDefinitionsOutput");
        formatter.field("definitions", &self.definitions);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListDeviceDefinitionsOutput`](crate::output::ListDeviceDefinitionsOutput).
pub mod list_device_definitions_output {

    /// A builder for [`ListDeviceDefinitionsOutput`](crate::output::ListDeviceDefinitionsOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) definitions:
            std::option::Option<std::vec::Vec<crate::model::DefinitionInformation>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `definitions`.
        ///
        /// To override the contents of this collection use [`set_definitions`](Self::set_definitions).
        ///
        /// Information about a definition.
        pub fn definitions(mut self, input: crate::model::DefinitionInformation) -> Self {
            let mut v = self.definitions.unwrap_or_default();
            v.push(input);
            self.definitions = Some(v);
            self
        }
        /// Information about a definition.
        pub fn set_definitions(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::DefinitionInformation>>,
        ) -> Self {
            self.definitions = input;
            self
        }
        /// The token for the next set of results, or ''null'' if there are no additional results.
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// The token for the next set of results, or ''null'' if there are no additional results.
        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 [`ListDeviceDefinitionsOutput`](crate::output::ListDeviceDefinitionsOutput).
        pub fn build(self) -> crate::output::ListDeviceDefinitionsOutput {
            crate::output::ListDeviceDefinitionsOutput {
                definitions: self.definitions,
                next_token: self.next_token,
            }
        }
    }
}
impl ListDeviceDefinitionsOutput {
    /// Creates a new builder-style object to manufacture [`ListDeviceDefinitionsOutput`](crate::output::ListDeviceDefinitionsOutput).
    pub fn builder() -> crate::output::list_device_definitions_output::Builder {
        crate::output::list_device_definitions_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListDeploymentsOutput {
    /// A list of deployments for the requested groups.
    #[doc(hidden)]
    pub deployments: std::option::Option<std::vec::Vec<crate::model::Deployment>>,
    /// The token for the next set of results, or ''null'' if there are no additional results.
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
}
impl ListDeploymentsOutput {
    /// A list of deployments for the requested groups.
    pub fn deployments(&self) -> std::option::Option<&[crate::model::Deployment]> {
        self.deployments.as_deref()
    }
    /// The token for the next set of results, or ''null'' if there are no additional results.
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListDeploymentsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListDeploymentsOutput");
        formatter.field("deployments", &self.deployments);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListDeploymentsOutput`](crate::output::ListDeploymentsOutput).
pub mod list_deployments_output {

    /// A builder for [`ListDeploymentsOutput`](crate::output::ListDeploymentsOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) deployments: std::option::Option<std::vec::Vec<crate::model::Deployment>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `deployments`.
        ///
        /// To override the contents of this collection use [`set_deployments`](Self::set_deployments).
        ///
        /// A list of deployments for the requested groups.
        pub fn deployments(mut self, input: crate::model::Deployment) -> Self {
            let mut v = self.deployments.unwrap_or_default();
            v.push(input);
            self.deployments = Some(v);
            self
        }
        /// A list of deployments for the requested groups.
        pub fn set_deployments(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Deployment>>,
        ) -> Self {
            self.deployments = input;
            self
        }
        /// The token for the next set of results, or ''null'' if there are no additional results.
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// The token for the next set of results, or ''null'' if there are no additional results.
        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 [`ListDeploymentsOutput`](crate::output::ListDeploymentsOutput).
        pub fn build(self) -> crate::output::ListDeploymentsOutput {
            crate::output::ListDeploymentsOutput {
                deployments: self.deployments,
                next_token: self.next_token,
            }
        }
    }
}
impl ListDeploymentsOutput {
    /// Creates a new builder-style object to manufacture [`ListDeploymentsOutput`](crate::output::ListDeploymentsOutput).
    pub fn builder() -> crate::output::list_deployments_output::Builder {
        crate::output::list_deployments_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListCoreDefinitionVersionsOutput {
    /// The token for the next set of results, or ''null'' if there are no additional results.
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
    /// Information about a version.
    #[doc(hidden)]
    pub versions: std::option::Option<std::vec::Vec<crate::model::VersionInformation>>,
}
impl ListCoreDefinitionVersionsOutput {
    /// The token for the next set of results, or ''null'' if there are no additional results.
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// Information about a version.
    pub fn versions(&self) -> std::option::Option<&[crate::model::VersionInformation]> {
        self.versions.as_deref()
    }
}
impl std::fmt::Debug for ListCoreDefinitionVersionsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListCoreDefinitionVersionsOutput");
        formatter.field("next_token", &self.next_token);
        formatter.field("versions", &self.versions);
        formatter.finish()
    }
}
/// See [`ListCoreDefinitionVersionsOutput`](crate::output::ListCoreDefinitionVersionsOutput).
pub mod list_core_definition_versions_output {

    /// A builder for [`ListCoreDefinitionVersionsOutput`](crate::output::ListCoreDefinitionVersionsOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) versions: std::option::Option<std::vec::Vec<crate::model::VersionInformation>>,
    }
    impl Builder {
        /// The token for the next set of results, or ''null'' if there are no additional results.
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// The token for the next set of results, or ''null'' if there are no additional results.
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Appends an item to `versions`.
        ///
        /// To override the contents of this collection use [`set_versions`](Self::set_versions).
        ///
        /// Information about a version.
        pub fn versions(mut self, input: crate::model::VersionInformation) -> Self {
            let mut v = self.versions.unwrap_or_default();
            v.push(input);
            self.versions = Some(v);
            self
        }
        /// Information about a version.
        pub fn set_versions(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::VersionInformation>>,
        ) -> Self {
            self.versions = input;
            self
        }
        /// Consumes the builder and constructs a [`ListCoreDefinitionVersionsOutput`](crate::output::ListCoreDefinitionVersionsOutput).
        pub fn build(self) -> crate::output::ListCoreDefinitionVersionsOutput {
            crate::output::ListCoreDefinitionVersionsOutput {
                next_token: self.next_token,
                versions: self.versions,
            }
        }
    }
}
impl ListCoreDefinitionVersionsOutput {
    /// Creates a new builder-style object to manufacture [`ListCoreDefinitionVersionsOutput`](crate::output::ListCoreDefinitionVersionsOutput).
    pub fn builder() -> crate::output::list_core_definition_versions_output::Builder {
        crate::output::list_core_definition_versions_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListCoreDefinitionsOutput {
    /// Information about a definition.
    #[doc(hidden)]
    pub definitions: std::option::Option<std::vec::Vec<crate::model::DefinitionInformation>>,
    /// The token for the next set of results, or ''null'' if there are no additional results.
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
}
impl ListCoreDefinitionsOutput {
    /// Information about a definition.
    pub fn definitions(&self) -> std::option::Option<&[crate::model::DefinitionInformation]> {
        self.definitions.as_deref()
    }
    /// The token for the next set of results, or ''null'' if there are no additional results.
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListCoreDefinitionsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListCoreDefinitionsOutput");
        formatter.field("definitions", &self.definitions);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListCoreDefinitionsOutput`](crate::output::ListCoreDefinitionsOutput).
pub mod list_core_definitions_output {

    /// A builder for [`ListCoreDefinitionsOutput`](crate::output::ListCoreDefinitionsOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) definitions:
            std::option::Option<std::vec::Vec<crate::model::DefinitionInformation>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `definitions`.
        ///
        /// To override the contents of this collection use [`set_definitions`](Self::set_definitions).
        ///
        /// Information about a definition.
        pub fn definitions(mut self, input: crate::model::DefinitionInformation) -> Self {
            let mut v = self.definitions.unwrap_or_default();
            v.push(input);
            self.definitions = Some(v);
            self
        }
        /// Information about a definition.
        pub fn set_definitions(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::DefinitionInformation>>,
        ) -> Self {
            self.definitions = input;
            self
        }
        /// The token for the next set of results, or ''null'' if there are no additional results.
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// The token for the next set of results, or ''null'' if there are no additional results.
        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 [`ListCoreDefinitionsOutput`](crate::output::ListCoreDefinitionsOutput).
        pub fn build(self) -> crate::output::ListCoreDefinitionsOutput {
            crate::output::ListCoreDefinitionsOutput {
                definitions: self.definitions,
                next_token: self.next_token,
            }
        }
    }
}
impl ListCoreDefinitionsOutput {
    /// Creates a new builder-style object to manufacture [`ListCoreDefinitionsOutput`](crate::output::ListCoreDefinitionsOutput).
    pub fn builder() -> crate::output::list_core_definitions_output::Builder {
        crate::output::list_core_definitions_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListConnectorDefinitionVersionsOutput {
    /// The token for the next set of results, or ''null'' if there are no additional results.
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
    /// Information about a version.
    #[doc(hidden)]
    pub versions: std::option::Option<std::vec::Vec<crate::model::VersionInformation>>,
}
impl ListConnectorDefinitionVersionsOutput {
    /// The token for the next set of results, or ''null'' if there are no additional results.
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// Information about a version.
    pub fn versions(&self) -> std::option::Option<&[crate::model::VersionInformation]> {
        self.versions.as_deref()
    }
}
impl std::fmt::Debug for ListConnectorDefinitionVersionsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListConnectorDefinitionVersionsOutput");
        formatter.field("next_token", &self.next_token);
        formatter.field("versions", &self.versions);
        formatter.finish()
    }
}
/// See [`ListConnectorDefinitionVersionsOutput`](crate::output::ListConnectorDefinitionVersionsOutput).
pub mod list_connector_definition_versions_output {

    /// A builder for [`ListConnectorDefinitionVersionsOutput`](crate::output::ListConnectorDefinitionVersionsOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) versions: std::option::Option<std::vec::Vec<crate::model::VersionInformation>>,
    }
    impl Builder {
        /// The token for the next set of results, or ''null'' if there are no additional results.
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// The token for the next set of results, or ''null'' if there are no additional results.
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Appends an item to `versions`.
        ///
        /// To override the contents of this collection use [`set_versions`](Self::set_versions).
        ///
        /// Information about a version.
        pub fn versions(mut self, input: crate::model::VersionInformation) -> Self {
            let mut v = self.versions.unwrap_or_default();
            v.push(input);
            self.versions = Some(v);
            self
        }
        /// Information about a version.
        pub fn set_versions(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::VersionInformation>>,
        ) -> Self {
            self.versions = input;
            self
        }
        /// Consumes the builder and constructs a [`ListConnectorDefinitionVersionsOutput`](crate::output::ListConnectorDefinitionVersionsOutput).
        pub fn build(self) -> crate::output::ListConnectorDefinitionVersionsOutput {
            crate::output::ListConnectorDefinitionVersionsOutput {
                next_token: self.next_token,
                versions: self.versions,
            }
        }
    }
}
impl ListConnectorDefinitionVersionsOutput {
    /// Creates a new builder-style object to manufacture [`ListConnectorDefinitionVersionsOutput`](crate::output::ListConnectorDefinitionVersionsOutput).
    pub fn builder() -> crate::output::list_connector_definition_versions_output::Builder {
        crate::output::list_connector_definition_versions_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListConnectorDefinitionsOutput {
    /// Information about a definition.
    #[doc(hidden)]
    pub definitions: std::option::Option<std::vec::Vec<crate::model::DefinitionInformation>>,
    /// The token for the next set of results, or ''null'' if there are no additional results.
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
}
impl ListConnectorDefinitionsOutput {
    /// Information about a definition.
    pub fn definitions(&self) -> std::option::Option<&[crate::model::DefinitionInformation]> {
        self.definitions.as_deref()
    }
    /// The token for the next set of results, or ''null'' if there are no additional results.
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListConnectorDefinitionsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListConnectorDefinitionsOutput");
        formatter.field("definitions", &self.definitions);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListConnectorDefinitionsOutput`](crate::output::ListConnectorDefinitionsOutput).
pub mod list_connector_definitions_output {

    /// A builder for [`ListConnectorDefinitionsOutput`](crate::output::ListConnectorDefinitionsOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) definitions:
            std::option::Option<std::vec::Vec<crate::model::DefinitionInformation>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `definitions`.
        ///
        /// To override the contents of this collection use [`set_definitions`](Self::set_definitions).
        ///
        /// Information about a definition.
        pub fn definitions(mut self, input: crate::model::DefinitionInformation) -> Self {
            let mut v = self.definitions.unwrap_or_default();
            v.push(input);
            self.definitions = Some(v);
            self
        }
        /// Information about a definition.
        pub fn set_definitions(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::DefinitionInformation>>,
        ) -> Self {
            self.definitions = input;
            self
        }
        /// The token for the next set of results, or ''null'' if there are no additional results.
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// The token for the next set of results, or ''null'' if there are no additional results.
        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 [`ListConnectorDefinitionsOutput`](crate::output::ListConnectorDefinitionsOutput).
        pub fn build(self) -> crate::output::ListConnectorDefinitionsOutput {
            crate::output::ListConnectorDefinitionsOutput {
                definitions: self.definitions,
                next_token: self.next_token,
            }
        }
    }
}
impl ListConnectorDefinitionsOutput {
    /// Creates a new builder-style object to manufacture [`ListConnectorDefinitionsOutput`](crate::output::ListConnectorDefinitionsOutput).
    pub fn builder() -> crate::output::list_connector_definitions_output::Builder {
        crate::output::list_connector_definitions_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListBulkDeploymentsOutput {
    /// A list of bulk deployments.
    #[doc(hidden)]
    pub bulk_deployments: std::option::Option<std::vec::Vec<crate::model::BulkDeployment>>,
    /// The token for the next set of results, or ''null'' if there are no additional results.
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
}
impl ListBulkDeploymentsOutput {
    /// A list of bulk deployments.
    pub fn bulk_deployments(&self) -> std::option::Option<&[crate::model::BulkDeployment]> {
        self.bulk_deployments.as_deref()
    }
    /// The token for the next set of results, or ''null'' if there are no additional results.
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListBulkDeploymentsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListBulkDeploymentsOutput");
        formatter.field("bulk_deployments", &self.bulk_deployments);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListBulkDeploymentsOutput`](crate::output::ListBulkDeploymentsOutput).
pub mod list_bulk_deployments_output {

    /// A builder for [`ListBulkDeploymentsOutput`](crate::output::ListBulkDeploymentsOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) bulk_deployments:
            std::option::Option<std::vec::Vec<crate::model::BulkDeployment>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `bulk_deployments`.
        ///
        /// To override the contents of this collection use [`set_bulk_deployments`](Self::set_bulk_deployments).
        ///
        /// A list of bulk deployments.
        pub fn bulk_deployments(mut self, input: crate::model::BulkDeployment) -> Self {
            let mut v = self.bulk_deployments.unwrap_or_default();
            v.push(input);
            self.bulk_deployments = Some(v);
            self
        }
        /// A list of bulk deployments.
        pub fn set_bulk_deployments(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::BulkDeployment>>,
        ) -> Self {
            self.bulk_deployments = input;
            self
        }
        /// The token for the next set of results, or ''null'' if there are no additional results.
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// The token for the next set of results, or ''null'' if there are no additional results.
        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 [`ListBulkDeploymentsOutput`](crate::output::ListBulkDeploymentsOutput).
        pub fn build(self) -> crate::output::ListBulkDeploymentsOutput {
            crate::output::ListBulkDeploymentsOutput {
                bulk_deployments: self.bulk_deployments,
                next_token: self.next_token,
            }
        }
    }
}
impl ListBulkDeploymentsOutput {
    /// Creates a new builder-style object to manufacture [`ListBulkDeploymentsOutput`](crate::output::ListBulkDeploymentsOutput).
    pub fn builder() -> crate::output::list_bulk_deployments_output::Builder {
        crate::output::list_bulk_deployments_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListBulkDeploymentDetailedReportsOutput {
    /// A list of the individual group deployments in the bulk deployment operation.
    #[doc(hidden)]
    pub deployments: std::option::Option<std::vec::Vec<crate::model::BulkDeploymentResult>>,
    /// The token for the next set of results, or ''null'' if there are no additional results.
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
}
impl ListBulkDeploymentDetailedReportsOutput {
    /// A list of the individual group deployments in the bulk deployment operation.
    pub fn deployments(&self) -> std::option::Option<&[crate::model::BulkDeploymentResult]> {
        self.deployments.as_deref()
    }
    /// The token for the next set of results, or ''null'' if there are no additional results.
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListBulkDeploymentDetailedReportsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListBulkDeploymentDetailedReportsOutput");
        formatter.field("deployments", &self.deployments);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListBulkDeploymentDetailedReportsOutput`](crate::output::ListBulkDeploymentDetailedReportsOutput).
pub mod list_bulk_deployment_detailed_reports_output {

    /// A builder for [`ListBulkDeploymentDetailedReportsOutput`](crate::output::ListBulkDeploymentDetailedReportsOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) deployments:
            std::option::Option<std::vec::Vec<crate::model::BulkDeploymentResult>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `deployments`.
        ///
        /// To override the contents of this collection use [`set_deployments`](Self::set_deployments).
        ///
        /// A list of the individual group deployments in the bulk deployment operation.
        pub fn deployments(mut self, input: crate::model::BulkDeploymentResult) -> Self {
            let mut v = self.deployments.unwrap_or_default();
            v.push(input);
            self.deployments = Some(v);
            self
        }
        /// A list of the individual group deployments in the bulk deployment operation.
        pub fn set_deployments(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::BulkDeploymentResult>>,
        ) -> Self {
            self.deployments = input;
            self
        }
        /// The token for the next set of results, or ''null'' if there are no additional results.
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// The token for the next set of results, or ''null'' if there are no additional results.
        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 [`ListBulkDeploymentDetailedReportsOutput`](crate::output::ListBulkDeploymentDetailedReportsOutput).
        pub fn build(self) -> crate::output::ListBulkDeploymentDetailedReportsOutput {
            crate::output::ListBulkDeploymentDetailedReportsOutput {
                deployments: self.deployments,
                next_token: self.next_token,
            }
        }
    }
}
impl ListBulkDeploymentDetailedReportsOutput {
    /// Creates a new builder-style object to manufacture [`ListBulkDeploymentDetailedReportsOutput`](crate::output::ListBulkDeploymentDetailedReportsOutput).
    pub fn builder() -> crate::output::list_bulk_deployment_detailed_reports_output::Builder {
        crate::output::list_bulk_deployment_detailed_reports_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetThingRuntimeConfigurationOutput {
    /// Runtime configuration for a thing.
    #[doc(hidden)]
    pub runtime_configuration: std::option::Option<crate::model::RuntimeConfiguration>,
}
impl GetThingRuntimeConfigurationOutput {
    /// Runtime configuration for a thing.
    pub fn runtime_configuration(
        &self,
    ) -> std::option::Option<&crate::model::RuntimeConfiguration> {
        self.runtime_configuration.as_ref()
    }
}
impl std::fmt::Debug for GetThingRuntimeConfigurationOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetThingRuntimeConfigurationOutput");
        formatter.field("runtime_configuration", &self.runtime_configuration);
        formatter.finish()
    }
}
/// See [`GetThingRuntimeConfigurationOutput`](crate::output::GetThingRuntimeConfigurationOutput).
pub mod get_thing_runtime_configuration_output {

    /// A builder for [`GetThingRuntimeConfigurationOutput`](crate::output::GetThingRuntimeConfigurationOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) runtime_configuration: std::option::Option<crate::model::RuntimeConfiguration>,
    }
    impl Builder {
        /// Runtime configuration for a thing.
        pub fn runtime_configuration(mut self, input: crate::model::RuntimeConfiguration) -> Self {
            self.runtime_configuration = Some(input);
            self
        }
        /// Runtime configuration for a thing.
        pub fn set_runtime_configuration(
            mut self,
            input: std::option::Option<crate::model::RuntimeConfiguration>,
        ) -> Self {
            self.runtime_configuration = input;
            self
        }
        /// Consumes the builder and constructs a [`GetThingRuntimeConfigurationOutput`](crate::output::GetThingRuntimeConfigurationOutput).
        pub fn build(self) -> crate::output::GetThingRuntimeConfigurationOutput {
            crate::output::GetThingRuntimeConfigurationOutput {
                runtime_configuration: self.runtime_configuration,
            }
        }
    }
}
impl GetThingRuntimeConfigurationOutput {
    /// Creates a new builder-style object to manufacture [`GetThingRuntimeConfigurationOutput`](crate::output::GetThingRuntimeConfigurationOutput).
    pub fn builder() -> crate::output::get_thing_runtime_configuration_output::Builder {
        crate::output::get_thing_runtime_configuration_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetSubscriptionDefinitionVersionOutput {
    /// The ARN of the subscription definition version.
    #[doc(hidden)]
    pub arn: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the subscription definition version was created.
    #[doc(hidden)]
    pub creation_timestamp: std::option::Option<std::string::String>,
    /// Information about the subscription definition version.
    #[doc(hidden)]
    pub definition: std::option::Option<crate::model::SubscriptionDefinitionVersion>,
    /// The ID of the subscription definition version.
    #[doc(hidden)]
    pub id: std::option::Option<std::string::String>,
    /// The token for the next set of results, or ''null'' if there are no additional results.
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
    /// The version of the subscription definition version.
    #[doc(hidden)]
    pub version: std::option::Option<std::string::String>,
}
impl GetSubscriptionDefinitionVersionOutput {
    /// The ARN of the subscription definition version.
    pub fn arn(&self) -> std::option::Option<&str> {
        self.arn.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the subscription definition version was created.
    pub fn creation_timestamp(&self) -> std::option::Option<&str> {
        self.creation_timestamp.as_deref()
    }
    /// Information about the subscription definition version.
    pub fn definition(&self) -> std::option::Option<&crate::model::SubscriptionDefinitionVersion> {
        self.definition.as_ref()
    }
    /// The ID of the subscription definition version.
    pub fn id(&self) -> std::option::Option<&str> {
        self.id.as_deref()
    }
    /// The token for the next set of results, or ''null'' if there are no additional results.
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// The version of the subscription definition version.
    pub fn version(&self) -> std::option::Option<&str> {
        self.version.as_deref()
    }
}
impl std::fmt::Debug for GetSubscriptionDefinitionVersionOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetSubscriptionDefinitionVersionOutput");
        formatter.field("arn", &self.arn);
        formatter.field("creation_timestamp", &self.creation_timestamp);
        formatter.field("definition", &self.definition);
        formatter.field("id", &self.id);
        formatter.field("next_token", &self.next_token);
        formatter.field("version", &self.version);
        formatter.finish()
    }
}
/// See [`GetSubscriptionDefinitionVersionOutput`](crate::output::GetSubscriptionDefinitionVersionOutput).
pub mod get_subscription_definition_version_output {

    /// A builder for [`GetSubscriptionDefinitionVersionOutput`](crate::output::GetSubscriptionDefinitionVersionOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) arn: std::option::Option<std::string::String>,
        pub(crate) creation_timestamp: std::option::Option<std::string::String>,
        pub(crate) definition: std::option::Option<crate::model::SubscriptionDefinitionVersion>,
        pub(crate) id: std::option::Option<std::string::String>,
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) version: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The ARN of the subscription definition version.
        pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.arn = Some(input.into());
            self
        }
        /// The ARN of the subscription definition version.
        pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.arn = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the subscription definition version was created.
        pub fn creation_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.creation_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the subscription definition version was created.
        pub fn set_creation_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.creation_timestamp = input;
            self
        }
        /// Information about the subscription definition version.
        pub fn definition(mut self, input: crate::model::SubscriptionDefinitionVersion) -> Self {
            self.definition = Some(input);
            self
        }
        /// Information about the subscription definition version.
        pub fn set_definition(
            mut self,
            input: std::option::Option<crate::model::SubscriptionDefinitionVersion>,
        ) -> Self {
            self.definition = input;
            self
        }
        /// The ID of the subscription definition version.
        pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
            self.id = Some(input.into());
            self
        }
        /// The ID of the subscription definition version.
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.id = input;
            self
        }
        /// The token for the next set of results, or ''null'' if there are no additional results.
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// The token for the next set of results, or ''null'' if there are no additional results.
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// The version of the subscription definition version.
        pub fn version(mut self, input: impl Into<std::string::String>) -> Self {
            self.version = Some(input.into());
            self
        }
        /// The version of the subscription definition version.
        pub fn set_version(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.version = input;
            self
        }
        /// Consumes the builder and constructs a [`GetSubscriptionDefinitionVersionOutput`](crate::output::GetSubscriptionDefinitionVersionOutput).
        pub fn build(self) -> crate::output::GetSubscriptionDefinitionVersionOutput {
            crate::output::GetSubscriptionDefinitionVersionOutput {
                arn: self.arn,
                creation_timestamp: self.creation_timestamp,
                definition: self.definition,
                id: self.id,
                next_token: self.next_token,
                version: self.version,
            }
        }
    }
}
impl GetSubscriptionDefinitionVersionOutput {
    /// Creates a new builder-style object to manufacture [`GetSubscriptionDefinitionVersionOutput`](crate::output::GetSubscriptionDefinitionVersionOutput).
    pub fn builder() -> crate::output::get_subscription_definition_version_output::Builder {
        crate::output::get_subscription_definition_version_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetSubscriptionDefinitionOutput {
    /// The ARN of the definition.
    #[doc(hidden)]
    pub arn: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the definition was created.
    #[doc(hidden)]
    pub creation_timestamp: std::option::Option<std::string::String>,
    /// The ID of the definition.
    #[doc(hidden)]
    pub id: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the definition was last updated.
    #[doc(hidden)]
    pub last_updated_timestamp: std::option::Option<std::string::String>,
    /// The ID of the latest version associated with the definition.
    #[doc(hidden)]
    pub latest_version: std::option::Option<std::string::String>,
    /// The ARN of the latest version associated with the definition.
    #[doc(hidden)]
    pub latest_version_arn: std::option::Option<std::string::String>,
    /// The name of the definition.
    #[doc(hidden)]
    pub name: std::option::Option<std::string::String>,
    /// Tag(s) attached to the resource arn.
    #[doc(hidden)]
    pub tags:
        std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl GetSubscriptionDefinitionOutput {
    /// The ARN of the definition.
    pub fn arn(&self) -> std::option::Option<&str> {
        self.arn.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the definition was created.
    pub fn creation_timestamp(&self) -> std::option::Option<&str> {
        self.creation_timestamp.as_deref()
    }
    /// The ID of the definition.
    pub fn id(&self) -> std::option::Option<&str> {
        self.id.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the definition was last updated.
    pub fn last_updated_timestamp(&self) -> std::option::Option<&str> {
        self.last_updated_timestamp.as_deref()
    }
    /// The ID of the latest version associated with the definition.
    pub fn latest_version(&self) -> std::option::Option<&str> {
        self.latest_version.as_deref()
    }
    /// The ARN of the latest version associated with the definition.
    pub fn latest_version_arn(&self) -> std::option::Option<&str> {
        self.latest_version_arn.as_deref()
    }
    /// The name of the definition.
    pub fn name(&self) -> std::option::Option<&str> {
        self.name.as_deref()
    }
    /// Tag(s) attached to the resource arn.
    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 GetSubscriptionDefinitionOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetSubscriptionDefinitionOutput");
        formatter.field("arn", &self.arn);
        formatter.field("creation_timestamp", &self.creation_timestamp);
        formatter.field("id", &self.id);
        formatter.field("last_updated_timestamp", &self.last_updated_timestamp);
        formatter.field("latest_version", &self.latest_version);
        formatter.field("latest_version_arn", &self.latest_version_arn);
        formatter.field("name", &self.name);
        formatter.field("tags", &self.tags);
        formatter.finish()
    }
}
/// See [`GetSubscriptionDefinitionOutput`](crate::output::GetSubscriptionDefinitionOutput).
pub mod get_subscription_definition_output {

    /// A builder for [`GetSubscriptionDefinitionOutput`](crate::output::GetSubscriptionDefinitionOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) arn: std::option::Option<std::string::String>,
        pub(crate) creation_timestamp: std::option::Option<std::string::String>,
        pub(crate) id: std::option::Option<std::string::String>,
        pub(crate) last_updated_timestamp: std::option::Option<std::string::String>,
        pub(crate) latest_version: std::option::Option<std::string::String>,
        pub(crate) latest_version_arn: std::option::Option<std::string::String>,
        pub(crate) name: std::option::Option<std::string::String>,
        pub(crate) tags: std::option::Option<
            std::collections::HashMap<std::string::String, std::string::String>,
        >,
    }
    impl Builder {
        /// The ARN of the definition.
        pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.arn = Some(input.into());
            self
        }
        /// The ARN of the definition.
        pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.arn = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was created.
        pub fn creation_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.creation_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was created.
        pub fn set_creation_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.creation_timestamp = input;
            self
        }
        /// The ID of the definition.
        pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
            self.id = Some(input.into());
            self
        }
        /// The ID of the definition.
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.id = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was last updated.
        pub fn last_updated_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.last_updated_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was last updated.
        pub fn set_last_updated_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.last_updated_timestamp = input;
            self
        }
        /// The ID of the latest version associated with the definition.
        pub fn latest_version(mut self, input: impl Into<std::string::String>) -> Self {
            self.latest_version = Some(input.into());
            self
        }
        /// The ID of the latest version associated with the definition.
        pub fn set_latest_version(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.latest_version = input;
            self
        }
        /// The ARN of the latest version associated with the definition.
        pub fn latest_version_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.latest_version_arn = Some(input.into());
            self
        }
        /// The ARN of the latest version associated with the definition.
        pub fn set_latest_version_arn(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.latest_version_arn = input;
            self
        }
        /// The name of the definition.
        pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
            self.name = Some(input.into());
            self
        }
        /// The name of the definition.
        pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.name = input;
            self
        }
        /// Adds a key-value pair to `tags`.
        ///
        /// To override the contents of this collection use [`set_tags`](Self::set_tags).
        ///
        /// Tag(s) attached to the resource arn.
        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
        }
        /// Tag(s) attached to the resource arn.
        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 [`GetSubscriptionDefinitionOutput`](crate::output::GetSubscriptionDefinitionOutput).
        pub fn build(self) -> crate::output::GetSubscriptionDefinitionOutput {
            crate::output::GetSubscriptionDefinitionOutput {
                arn: self.arn,
                creation_timestamp: self.creation_timestamp,
                id: self.id,
                last_updated_timestamp: self.last_updated_timestamp,
                latest_version: self.latest_version,
                latest_version_arn: self.latest_version_arn,
                name: self.name,
                tags: self.tags,
            }
        }
    }
}
impl GetSubscriptionDefinitionOutput {
    /// Creates a new builder-style object to manufacture [`GetSubscriptionDefinitionOutput`](crate::output::GetSubscriptionDefinitionOutput).
    pub fn builder() -> crate::output::get_subscription_definition_output::Builder {
        crate::output::get_subscription_definition_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetServiceRoleForAccountOutput {
    /// The time when the service role was associated with the account.
    #[doc(hidden)]
    pub associated_at: std::option::Option<std::string::String>,
    /// The ARN of the role which is associated with the account.
    #[doc(hidden)]
    pub role_arn: std::option::Option<std::string::String>,
}
impl GetServiceRoleForAccountOutput {
    /// The time when the service role was associated with the account.
    pub fn associated_at(&self) -> std::option::Option<&str> {
        self.associated_at.as_deref()
    }
    /// The ARN of the role which is associated with the account.
    pub fn role_arn(&self) -> std::option::Option<&str> {
        self.role_arn.as_deref()
    }
}
impl std::fmt::Debug for GetServiceRoleForAccountOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetServiceRoleForAccountOutput");
        formatter.field("associated_at", &self.associated_at);
        formatter.field("role_arn", &self.role_arn);
        formatter.finish()
    }
}
/// See [`GetServiceRoleForAccountOutput`](crate::output::GetServiceRoleForAccountOutput).
pub mod get_service_role_for_account_output {

    /// A builder for [`GetServiceRoleForAccountOutput`](crate::output::GetServiceRoleForAccountOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) associated_at: std::option::Option<std::string::String>,
        pub(crate) role_arn: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The time when the service role was associated with the account.
        pub fn associated_at(mut self, input: impl Into<std::string::String>) -> Self {
            self.associated_at = Some(input.into());
            self
        }
        /// The time when the service role was associated with the account.
        pub fn set_associated_at(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.associated_at = input;
            self
        }
        /// The ARN of the role which is associated with the account.
        pub fn role_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.role_arn = Some(input.into());
            self
        }
        /// The ARN of the role which is associated with the account.
        pub fn set_role_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.role_arn = input;
            self
        }
        /// Consumes the builder and constructs a [`GetServiceRoleForAccountOutput`](crate::output::GetServiceRoleForAccountOutput).
        pub fn build(self) -> crate::output::GetServiceRoleForAccountOutput {
            crate::output::GetServiceRoleForAccountOutput {
                associated_at: self.associated_at,
                role_arn: self.role_arn,
            }
        }
    }
}
impl GetServiceRoleForAccountOutput {
    /// Creates a new builder-style object to manufacture [`GetServiceRoleForAccountOutput`](crate::output::GetServiceRoleForAccountOutput).
    pub fn builder() -> crate::output::get_service_role_for_account_output::Builder {
        crate::output::get_service_role_for_account_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetResourceDefinitionVersionOutput {
    /// Arn of the resource definition version.
    #[doc(hidden)]
    pub arn: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the resource definition version was created.
    #[doc(hidden)]
    pub creation_timestamp: std::option::Option<std::string::String>,
    /// Information about the definition.
    #[doc(hidden)]
    pub definition: std::option::Option<crate::model::ResourceDefinitionVersion>,
    /// The ID of the resource definition version.
    #[doc(hidden)]
    pub id: std::option::Option<std::string::String>,
    /// The version of the resource definition version.
    #[doc(hidden)]
    pub version: std::option::Option<std::string::String>,
}
impl GetResourceDefinitionVersionOutput {
    /// Arn of the resource definition version.
    pub fn arn(&self) -> std::option::Option<&str> {
        self.arn.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the resource definition version was created.
    pub fn creation_timestamp(&self) -> std::option::Option<&str> {
        self.creation_timestamp.as_deref()
    }
    /// Information about the definition.
    pub fn definition(&self) -> std::option::Option<&crate::model::ResourceDefinitionVersion> {
        self.definition.as_ref()
    }
    /// The ID of the resource definition version.
    pub fn id(&self) -> std::option::Option<&str> {
        self.id.as_deref()
    }
    /// The version of the resource definition version.
    pub fn version(&self) -> std::option::Option<&str> {
        self.version.as_deref()
    }
}
impl std::fmt::Debug for GetResourceDefinitionVersionOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetResourceDefinitionVersionOutput");
        formatter.field("arn", &self.arn);
        formatter.field("creation_timestamp", &self.creation_timestamp);
        formatter.field("definition", &self.definition);
        formatter.field("id", &self.id);
        formatter.field("version", &self.version);
        formatter.finish()
    }
}
/// See [`GetResourceDefinitionVersionOutput`](crate::output::GetResourceDefinitionVersionOutput).
pub mod get_resource_definition_version_output {

    /// A builder for [`GetResourceDefinitionVersionOutput`](crate::output::GetResourceDefinitionVersionOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) arn: std::option::Option<std::string::String>,
        pub(crate) creation_timestamp: std::option::Option<std::string::String>,
        pub(crate) definition: std::option::Option<crate::model::ResourceDefinitionVersion>,
        pub(crate) id: std::option::Option<std::string::String>,
        pub(crate) version: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Arn of the resource definition version.
        pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.arn = Some(input.into());
            self
        }
        /// Arn of the resource definition version.
        pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.arn = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the resource definition version was created.
        pub fn creation_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.creation_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the resource definition version was created.
        pub fn set_creation_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.creation_timestamp = input;
            self
        }
        /// Information about the definition.
        pub fn definition(mut self, input: crate::model::ResourceDefinitionVersion) -> Self {
            self.definition = Some(input);
            self
        }
        /// Information about the definition.
        pub fn set_definition(
            mut self,
            input: std::option::Option<crate::model::ResourceDefinitionVersion>,
        ) -> Self {
            self.definition = input;
            self
        }
        /// The ID of the resource definition version.
        pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
            self.id = Some(input.into());
            self
        }
        /// The ID of the resource definition version.
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.id = input;
            self
        }
        /// The version of the resource definition version.
        pub fn version(mut self, input: impl Into<std::string::String>) -> Self {
            self.version = Some(input.into());
            self
        }
        /// The version of the resource definition version.
        pub fn set_version(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.version = input;
            self
        }
        /// Consumes the builder and constructs a [`GetResourceDefinitionVersionOutput`](crate::output::GetResourceDefinitionVersionOutput).
        pub fn build(self) -> crate::output::GetResourceDefinitionVersionOutput {
            crate::output::GetResourceDefinitionVersionOutput {
                arn: self.arn,
                creation_timestamp: self.creation_timestamp,
                definition: self.definition,
                id: self.id,
                version: self.version,
            }
        }
    }
}
impl GetResourceDefinitionVersionOutput {
    /// Creates a new builder-style object to manufacture [`GetResourceDefinitionVersionOutput`](crate::output::GetResourceDefinitionVersionOutput).
    pub fn builder() -> crate::output::get_resource_definition_version_output::Builder {
        crate::output::get_resource_definition_version_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetResourceDefinitionOutput {
    /// The ARN of the definition.
    #[doc(hidden)]
    pub arn: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the definition was created.
    #[doc(hidden)]
    pub creation_timestamp: std::option::Option<std::string::String>,
    /// The ID of the definition.
    #[doc(hidden)]
    pub id: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the definition was last updated.
    #[doc(hidden)]
    pub last_updated_timestamp: std::option::Option<std::string::String>,
    /// The ID of the latest version associated with the definition.
    #[doc(hidden)]
    pub latest_version: std::option::Option<std::string::String>,
    /// The ARN of the latest version associated with the definition.
    #[doc(hidden)]
    pub latest_version_arn: std::option::Option<std::string::String>,
    /// The name of the definition.
    #[doc(hidden)]
    pub name: std::option::Option<std::string::String>,
    /// Tag(s) attached to the resource arn.
    #[doc(hidden)]
    pub tags:
        std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl GetResourceDefinitionOutput {
    /// The ARN of the definition.
    pub fn arn(&self) -> std::option::Option<&str> {
        self.arn.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the definition was created.
    pub fn creation_timestamp(&self) -> std::option::Option<&str> {
        self.creation_timestamp.as_deref()
    }
    /// The ID of the definition.
    pub fn id(&self) -> std::option::Option<&str> {
        self.id.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the definition was last updated.
    pub fn last_updated_timestamp(&self) -> std::option::Option<&str> {
        self.last_updated_timestamp.as_deref()
    }
    /// The ID of the latest version associated with the definition.
    pub fn latest_version(&self) -> std::option::Option<&str> {
        self.latest_version.as_deref()
    }
    /// The ARN of the latest version associated with the definition.
    pub fn latest_version_arn(&self) -> std::option::Option<&str> {
        self.latest_version_arn.as_deref()
    }
    /// The name of the definition.
    pub fn name(&self) -> std::option::Option<&str> {
        self.name.as_deref()
    }
    /// Tag(s) attached to the resource arn.
    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 GetResourceDefinitionOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetResourceDefinitionOutput");
        formatter.field("arn", &self.arn);
        formatter.field("creation_timestamp", &self.creation_timestamp);
        formatter.field("id", &self.id);
        formatter.field("last_updated_timestamp", &self.last_updated_timestamp);
        formatter.field("latest_version", &self.latest_version);
        formatter.field("latest_version_arn", &self.latest_version_arn);
        formatter.field("name", &self.name);
        formatter.field("tags", &self.tags);
        formatter.finish()
    }
}
/// See [`GetResourceDefinitionOutput`](crate::output::GetResourceDefinitionOutput).
pub mod get_resource_definition_output {

    /// A builder for [`GetResourceDefinitionOutput`](crate::output::GetResourceDefinitionOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) arn: std::option::Option<std::string::String>,
        pub(crate) creation_timestamp: std::option::Option<std::string::String>,
        pub(crate) id: std::option::Option<std::string::String>,
        pub(crate) last_updated_timestamp: std::option::Option<std::string::String>,
        pub(crate) latest_version: std::option::Option<std::string::String>,
        pub(crate) latest_version_arn: std::option::Option<std::string::String>,
        pub(crate) name: std::option::Option<std::string::String>,
        pub(crate) tags: std::option::Option<
            std::collections::HashMap<std::string::String, std::string::String>,
        >,
    }
    impl Builder {
        /// The ARN of the definition.
        pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.arn = Some(input.into());
            self
        }
        /// The ARN of the definition.
        pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.arn = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was created.
        pub fn creation_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.creation_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was created.
        pub fn set_creation_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.creation_timestamp = input;
            self
        }
        /// The ID of the definition.
        pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
            self.id = Some(input.into());
            self
        }
        /// The ID of the definition.
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.id = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was last updated.
        pub fn last_updated_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.last_updated_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was last updated.
        pub fn set_last_updated_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.last_updated_timestamp = input;
            self
        }
        /// The ID of the latest version associated with the definition.
        pub fn latest_version(mut self, input: impl Into<std::string::String>) -> Self {
            self.latest_version = Some(input.into());
            self
        }
        /// The ID of the latest version associated with the definition.
        pub fn set_latest_version(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.latest_version = input;
            self
        }
        /// The ARN of the latest version associated with the definition.
        pub fn latest_version_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.latest_version_arn = Some(input.into());
            self
        }
        /// The ARN of the latest version associated with the definition.
        pub fn set_latest_version_arn(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.latest_version_arn = input;
            self
        }
        /// The name of the definition.
        pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
            self.name = Some(input.into());
            self
        }
        /// The name of the definition.
        pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.name = input;
            self
        }
        /// Adds a key-value pair to `tags`.
        ///
        /// To override the contents of this collection use [`set_tags`](Self::set_tags).
        ///
        /// Tag(s) attached to the resource arn.
        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
        }
        /// Tag(s) attached to the resource arn.
        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 [`GetResourceDefinitionOutput`](crate::output::GetResourceDefinitionOutput).
        pub fn build(self) -> crate::output::GetResourceDefinitionOutput {
            crate::output::GetResourceDefinitionOutput {
                arn: self.arn,
                creation_timestamp: self.creation_timestamp,
                id: self.id,
                last_updated_timestamp: self.last_updated_timestamp,
                latest_version: self.latest_version,
                latest_version_arn: self.latest_version_arn,
                name: self.name,
                tags: self.tags,
            }
        }
    }
}
impl GetResourceDefinitionOutput {
    /// Creates a new builder-style object to manufacture [`GetResourceDefinitionOutput`](crate::output::GetResourceDefinitionOutput).
    pub fn builder() -> crate::output::get_resource_definition_output::Builder {
        crate::output::get_resource_definition_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetLoggerDefinitionVersionOutput {
    /// The ARN of the logger definition version.
    #[doc(hidden)]
    pub arn: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the logger definition version was created.
    #[doc(hidden)]
    pub creation_timestamp: std::option::Option<std::string::String>,
    /// Information about the logger definition version.
    #[doc(hidden)]
    pub definition: std::option::Option<crate::model::LoggerDefinitionVersion>,
    /// The ID of the logger definition version.
    #[doc(hidden)]
    pub id: std::option::Option<std::string::String>,
    /// The version of the logger definition version.
    #[doc(hidden)]
    pub version: std::option::Option<std::string::String>,
}
impl GetLoggerDefinitionVersionOutput {
    /// The ARN of the logger definition version.
    pub fn arn(&self) -> std::option::Option<&str> {
        self.arn.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the logger definition version was created.
    pub fn creation_timestamp(&self) -> std::option::Option<&str> {
        self.creation_timestamp.as_deref()
    }
    /// Information about the logger definition version.
    pub fn definition(&self) -> std::option::Option<&crate::model::LoggerDefinitionVersion> {
        self.definition.as_ref()
    }
    /// The ID of the logger definition version.
    pub fn id(&self) -> std::option::Option<&str> {
        self.id.as_deref()
    }
    /// The version of the logger definition version.
    pub fn version(&self) -> std::option::Option<&str> {
        self.version.as_deref()
    }
}
impl std::fmt::Debug for GetLoggerDefinitionVersionOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetLoggerDefinitionVersionOutput");
        formatter.field("arn", &self.arn);
        formatter.field("creation_timestamp", &self.creation_timestamp);
        formatter.field("definition", &self.definition);
        formatter.field("id", &self.id);
        formatter.field("version", &self.version);
        formatter.finish()
    }
}
/// See [`GetLoggerDefinitionVersionOutput`](crate::output::GetLoggerDefinitionVersionOutput).
pub mod get_logger_definition_version_output {

    /// A builder for [`GetLoggerDefinitionVersionOutput`](crate::output::GetLoggerDefinitionVersionOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) arn: std::option::Option<std::string::String>,
        pub(crate) creation_timestamp: std::option::Option<std::string::String>,
        pub(crate) definition: std::option::Option<crate::model::LoggerDefinitionVersion>,
        pub(crate) id: std::option::Option<std::string::String>,
        pub(crate) version: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The ARN of the logger definition version.
        pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.arn = Some(input.into());
            self
        }
        /// The ARN of the logger definition version.
        pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.arn = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the logger definition version was created.
        pub fn creation_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.creation_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the logger definition version was created.
        pub fn set_creation_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.creation_timestamp = input;
            self
        }
        /// Information about the logger definition version.
        pub fn definition(mut self, input: crate::model::LoggerDefinitionVersion) -> Self {
            self.definition = Some(input);
            self
        }
        /// Information about the logger definition version.
        pub fn set_definition(
            mut self,
            input: std::option::Option<crate::model::LoggerDefinitionVersion>,
        ) -> Self {
            self.definition = input;
            self
        }
        /// The ID of the logger definition version.
        pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
            self.id = Some(input.into());
            self
        }
        /// The ID of the logger definition version.
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.id = input;
            self
        }
        /// The version of the logger definition version.
        pub fn version(mut self, input: impl Into<std::string::String>) -> Self {
            self.version = Some(input.into());
            self
        }
        /// The version of the logger definition version.
        pub fn set_version(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.version = input;
            self
        }
        /// Consumes the builder and constructs a [`GetLoggerDefinitionVersionOutput`](crate::output::GetLoggerDefinitionVersionOutput).
        pub fn build(self) -> crate::output::GetLoggerDefinitionVersionOutput {
            crate::output::GetLoggerDefinitionVersionOutput {
                arn: self.arn,
                creation_timestamp: self.creation_timestamp,
                definition: self.definition,
                id: self.id,
                version: self.version,
            }
        }
    }
}
impl GetLoggerDefinitionVersionOutput {
    /// Creates a new builder-style object to manufacture [`GetLoggerDefinitionVersionOutput`](crate::output::GetLoggerDefinitionVersionOutput).
    pub fn builder() -> crate::output::get_logger_definition_version_output::Builder {
        crate::output::get_logger_definition_version_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetLoggerDefinitionOutput {
    /// The ARN of the definition.
    #[doc(hidden)]
    pub arn: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the definition was created.
    #[doc(hidden)]
    pub creation_timestamp: std::option::Option<std::string::String>,
    /// The ID of the definition.
    #[doc(hidden)]
    pub id: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the definition was last updated.
    #[doc(hidden)]
    pub last_updated_timestamp: std::option::Option<std::string::String>,
    /// The ID of the latest version associated with the definition.
    #[doc(hidden)]
    pub latest_version: std::option::Option<std::string::String>,
    /// The ARN of the latest version associated with the definition.
    #[doc(hidden)]
    pub latest_version_arn: std::option::Option<std::string::String>,
    /// The name of the definition.
    #[doc(hidden)]
    pub name: std::option::Option<std::string::String>,
    /// Tag(s) attached to the resource arn.
    #[doc(hidden)]
    pub tags:
        std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl GetLoggerDefinitionOutput {
    /// The ARN of the definition.
    pub fn arn(&self) -> std::option::Option<&str> {
        self.arn.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the definition was created.
    pub fn creation_timestamp(&self) -> std::option::Option<&str> {
        self.creation_timestamp.as_deref()
    }
    /// The ID of the definition.
    pub fn id(&self) -> std::option::Option<&str> {
        self.id.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the definition was last updated.
    pub fn last_updated_timestamp(&self) -> std::option::Option<&str> {
        self.last_updated_timestamp.as_deref()
    }
    /// The ID of the latest version associated with the definition.
    pub fn latest_version(&self) -> std::option::Option<&str> {
        self.latest_version.as_deref()
    }
    /// The ARN of the latest version associated with the definition.
    pub fn latest_version_arn(&self) -> std::option::Option<&str> {
        self.latest_version_arn.as_deref()
    }
    /// The name of the definition.
    pub fn name(&self) -> std::option::Option<&str> {
        self.name.as_deref()
    }
    /// Tag(s) attached to the resource arn.
    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 GetLoggerDefinitionOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetLoggerDefinitionOutput");
        formatter.field("arn", &self.arn);
        formatter.field("creation_timestamp", &self.creation_timestamp);
        formatter.field("id", &self.id);
        formatter.field("last_updated_timestamp", &self.last_updated_timestamp);
        formatter.field("latest_version", &self.latest_version);
        formatter.field("latest_version_arn", &self.latest_version_arn);
        formatter.field("name", &self.name);
        formatter.field("tags", &self.tags);
        formatter.finish()
    }
}
/// See [`GetLoggerDefinitionOutput`](crate::output::GetLoggerDefinitionOutput).
pub mod get_logger_definition_output {

    /// A builder for [`GetLoggerDefinitionOutput`](crate::output::GetLoggerDefinitionOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) arn: std::option::Option<std::string::String>,
        pub(crate) creation_timestamp: std::option::Option<std::string::String>,
        pub(crate) id: std::option::Option<std::string::String>,
        pub(crate) last_updated_timestamp: std::option::Option<std::string::String>,
        pub(crate) latest_version: std::option::Option<std::string::String>,
        pub(crate) latest_version_arn: std::option::Option<std::string::String>,
        pub(crate) name: std::option::Option<std::string::String>,
        pub(crate) tags: std::option::Option<
            std::collections::HashMap<std::string::String, std::string::String>,
        >,
    }
    impl Builder {
        /// The ARN of the definition.
        pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.arn = Some(input.into());
            self
        }
        /// The ARN of the definition.
        pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.arn = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was created.
        pub fn creation_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.creation_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was created.
        pub fn set_creation_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.creation_timestamp = input;
            self
        }
        /// The ID of the definition.
        pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
            self.id = Some(input.into());
            self
        }
        /// The ID of the definition.
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.id = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was last updated.
        pub fn last_updated_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.last_updated_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was last updated.
        pub fn set_last_updated_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.last_updated_timestamp = input;
            self
        }
        /// The ID of the latest version associated with the definition.
        pub fn latest_version(mut self, input: impl Into<std::string::String>) -> Self {
            self.latest_version = Some(input.into());
            self
        }
        /// The ID of the latest version associated with the definition.
        pub fn set_latest_version(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.latest_version = input;
            self
        }
        /// The ARN of the latest version associated with the definition.
        pub fn latest_version_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.latest_version_arn = Some(input.into());
            self
        }
        /// The ARN of the latest version associated with the definition.
        pub fn set_latest_version_arn(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.latest_version_arn = input;
            self
        }
        /// The name of the definition.
        pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
            self.name = Some(input.into());
            self
        }
        /// The name of the definition.
        pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.name = input;
            self
        }
        /// Adds a key-value pair to `tags`.
        ///
        /// To override the contents of this collection use [`set_tags`](Self::set_tags).
        ///
        /// Tag(s) attached to the resource arn.
        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
        }
        /// Tag(s) attached to the resource arn.
        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 [`GetLoggerDefinitionOutput`](crate::output::GetLoggerDefinitionOutput).
        pub fn build(self) -> crate::output::GetLoggerDefinitionOutput {
            crate::output::GetLoggerDefinitionOutput {
                arn: self.arn,
                creation_timestamp: self.creation_timestamp,
                id: self.id,
                last_updated_timestamp: self.last_updated_timestamp,
                latest_version: self.latest_version,
                latest_version_arn: self.latest_version_arn,
                name: self.name,
                tags: self.tags,
            }
        }
    }
}
impl GetLoggerDefinitionOutput {
    /// Creates a new builder-style object to manufacture [`GetLoggerDefinitionOutput`](crate::output::GetLoggerDefinitionOutput).
    pub fn builder() -> crate::output::get_logger_definition_output::Builder {
        crate::output::get_logger_definition_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetGroupVersionOutput {
    /// The ARN of the group version.
    #[doc(hidden)]
    pub arn: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the group version was created.
    #[doc(hidden)]
    pub creation_timestamp: std::option::Option<std::string::String>,
    /// Information about the group version definition.
    #[doc(hidden)]
    pub definition: std::option::Option<crate::model::GroupVersion>,
    /// The ID of the group that the version is associated with.
    #[doc(hidden)]
    pub id: std::option::Option<std::string::String>,
    /// The ID of the group version.
    #[doc(hidden)]
    pub version: std::option::Option<std::string::String>,
}
impl GetGroupVersionOutput {
    /// The ARN of the group version.
    pub fn arn(&self) -> std::option::Option<&str> {
        self.arn.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the group version was created.
    pub fn creation_timestamp(&self) -> std::option::Option<&str> {
        self.creation_timestamp.as_deref()
    }
    /// Information about the group version definition.
    pub fn definition(&self) -> std::option::Option<&crate::model::GroupVersion> {
        self.definition.as_ref()
    }
    /// The ID of the group that the version is associated with.
    pub fn id(&self) -> std::option::Option<&str> {
        self.id.as_deref()
    }
    /// The ID of the group version.
    pub fn version(&self) -> std::option::Option<&str> {
        self.version.as_deref()
    }
}
impl std::fmt::Debug for GetGroupVersionOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetGroupVersionOutput");
        formatter.field("arn", &self.arn);
        formatter.field("creation_timestamp", &self.creation_timestamp);
        formatter.field("definition", &self.definition);
        formatter.field("id", &self.id);
        formatter.field("version", &self.version);
        formatter.finish()
    }
}
/// See [`GetGroupVersionOutput`](crate::output::GetGroupVersionOutput).
pub mod get_group_version_output {

    /// A builder for [`GetGroupVersionOutput`](crate::output::GetGroupVersionOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) arn: std::option::Option<std::string::String>,
        pub(crate) creation_timestamp: std::option::Option<std::string::String>,
        pub(crate) definition: std::option::Option<crate::model::GroupVersion>,
        pub(crate) id: std::option::Option<std::string::String>,
        pub(crate) version: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The ARN of the group version.
        pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.arn = Some(input.into());
            self
        }
        /// The ARN of the group version.
        pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.arn = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the group version was created.
        pub fn creation_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.creation_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the group version was created.
        pub fn set_creation_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.creation_timestamp = input;
            self
        }
        /// Information about the group version definition.
        pub fn definition(mut self, input: crate::model::GroupVersion) -> Self {
            self.definition = Some(input);
            self
        }
        /// Information about the group version definition.
        pub fn set_definition(
            mut self,
            input: std::option::Option<crate::model::GroupVersion>,
        ) -> Self {
            self.definition = input;
            self
        }
        /// The ID of the group that the version is associated with.
        pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
            self.id = Some(input.into());
            self
        }
        /// The ID of the group that the version is associated with.
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.id = input;
            self
        }
        /// The ID of the group version.
        pub fn version(mut self, input: impl Into<std::string::String>) -> Self {
            self.version = Some(input.into());
            self
        }
        /// The ID of the group version.
        pub fn set_version(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.version = input;
            self
        }
        /// Consumes the builder and constructs a [`GetGroupVersionOutput`](crate::output::GetGroupVersionOutput).
        pub fn build(self) -> crate::output::GetGroupVersionOutput {
            crate::output::GetGroupVersionOutput {
                arn: self.arn,
                creation_timestamp: self.creation_timestamp,
                definition: self.definition,
                id: self.id,
                version: self.version,
            }
        }
    }
}
impl GetGroupVersionOutput {
    /// Creates a new builder-style object to manufacture [`GetGroupVersionOutput`](crate::output::GetGroupVersionOutput).
    pub fn builder() -> crate::output::get_group_version_output::Builder {
        crate::output::get_group_version_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetGroupCertificateConfigurationOutput {
    /// The amount of time remaining before the certificate authority expires, in milliseconds.
    #[doc(hidden)]
    pub certificate_authority_expiry_in_milliseconds: std::option::Option<std::string::String>,
    /// The amount of time remaining before the certificate expires, in milliseconds.
    #[doc(hidden)]
    pub certificate_expiry_in_milliseconds: std::option::Option<std::string::String>,
    /// The ID of the group certificate configuration.
    #[doc(hidden)]
    pub group_id: std::option::Option<std::string::String>,
}
impl GetGroupCertificateConfigurationOutput {
    /// The amount of time remaining before the certificate authority expires, in milliseconds.
    pub fn certificate_authority_expiry_in_milliseconds(&self) -> std::option::Option<&str> {
        self.certificate_authority_expiry_in_milliseconds.as_deref()
    }
    /// The amount of time remaining before the certificate expires, in milliseconds.
    pub fn certificate_expiry_in_milliseconds(&self) -> std::option::Option<&str> {
        self.certificate_expiry_in_milliseconds.as_deref()
    }
    /// The ID of the group certificate configuration.
    pub fn group_id(&self) -> std::option::Option<&str> {
        self.group_id.as_deref()
    }
}
impl std::fmt::Debug for GetGroupCertificateConfigurationOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetGroupCertificateConfigurationOutput");
        formatter.field(
            "certificate_authority_expiry_in_milliseconds",
            &self.certificate_authority_expiry_in_milliseconds,
        );
        formatter.field(
            "certificate_expiry_in_milliseconds",
            &self.certificate_expiry_in_milliseconds,
        );
        formatter.field("group_id", &self.group_id);
        formatter.finish()
    }
}
/// See [`GetGroupCertificateConfigurationOutput`](crate::output::GetGroupCertificateConfigurationOutput).
pub mod get_group_certificate_configuration_output {

    /// A builder for [`GetGroupCertificateConfigurationOutput`](crate::output::GetGroupCertificateConfigurationOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) certificate_authority_expiry_in_milliseconds:
            std::option::Option<std::string::String>,
        pub(crate) certificate_expiry_in_milliseconds: std::option::Option<std::string::String>,
        pub(crate) group_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The amount of time remaining before the certificate authority expires, in milliseconds.
        pub fn certificate_authority_expiry_in_milliseconds(
            mut self,
            input: impl Into<std::string::String>,
        ) -> Self {
            self.certificate_authority_expiry_in_milliseconds = Some(input.into());
            self
        }
        /// The amount of time remaining before the certificate authority expires, in milliseconds.
        pub fn set_certificate_authority_expiry_in_milliseconds(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.certificate_authority_expiry_in_milliseconds = input;
            self
        }
        /// The amount of time remaining before the certificate expires, in milliseconds.
        pub fn certificate_expiry_in_milliseconds(
            mut self,
            input: impl Into<std::string::String>,
        ) -> Self {
            self.certificate_expiry_in_milliseconds = Some(input.into());
            self
        }
        /// The amount of time remaining before the certificate expires, in milliseconds.
        pub fn set_certificate_expiry_in_milliseconds(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.certificate_expiry_in_milliseconds = input;
            self
        }
        /// The ID of the group certificate configuration.
        pub fn group_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.group_id = Some(input.into());
            self
        }
        /// The ID of the group certificate configuration.
        pub fn set_group_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.group_id = input;
            self
        }
        /// Consumes the builder and constructs a [`GetGroupCertificateConfigurationOutput`](crate::output::GetGroupCertificateConfigurationOutput).
        pub fn build(self) -> crate::output::GetGroupCertificateConfigurationOutput {
            crate::output::GetGroupCertificateConfigurationOutput {
                certificate_authority_expiry_in_milliseconds: self
                    .certificate_authority_expiry_in_milliseconds,
                certificate_expiry_in_milliseconds: self.certificate_expiry_in_milliseconds,
                group_id: self.group_id,
            }
        }
    }
}
impl GetGroupCertificateConfigurationOutput {
    /// Creates a new builder-style object to manufacture [`GetGroupCertificateConfigurationOutput`](crate::output::GetGroupCertificateConfigurationOutput).
    pub fn builder() -> crate::output::get_group_certificate_configuration_output::Builder {
        crate::output::get_group_certificate_configuration_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetGroupCertificateAuthorityOutput {
    /// The ARN of the certificate authority for the group.
    #[doc(hidden)]
    pub group_certificate_authority_arn: std::option::Option<std::string::String>,
    /// The ID of the certificate authority for the group.
    #[doc(hidden)]
    pub group_certificate_authority_id: std::option::Option<std::string::String>,
    /// The PEM encoded certificate for the group.
    #[doc(hidden)]
    pub pem_encoded_certificate: std::option::Option<std::string::String>,
}
impl GetGroupCertificateAuthorityOutput {
    /// The ARN of the certificate authority for the group.
    pub fn group_certificate_authority_arn(&self) -> std::option::Option<&str> {
        self.group_certificate_authority_arn.as_deref()
    }
    /// The ID of the certificate authority for the group.
    pub fn group_certificate_authority_id(&self) -> std::option::Option<&str> {
        self.group_certificate_authority_id.as_deref()
    }
    /// The PEM encoded certificate for the group.
    pub fn pem_encoded_certificate(&self) -> std::option::Option<&str> {
        self.pem_encoded_certificate.as_deref()
    }
}
impl std::fmt::Debug for GetGroupCertificateAuthorityOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetGroupCertificateAuthorityOutput");
        formatter.field(
            "group_certificate_authority_arn",
            &self.group_certificate_authority_arn,
        );
        formatter.field(
            "group_certificate_authority_id",
            &self.group_certificate_authority_id,
        );
        formatter.field("pem_encoded_certificate", &self.pem_encoded_certificate);
        formatter.finish()
    }
}
/// See [`GetGroupCertificateAuthorityOutput`](crate::output::GetGroupCertificateAuthorityOutput).
pub mod get_group_certificate_authority_output {

    /// A builder for [`GetGroupCertificateAuthorityOutput`](crate::output::GetGroupCertificateAuthorityOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) group_certificate_authority_arn: std::option::Option<std::string::String>,
        pub(crate) group_certificate_authority_id: std::option::Option<std::string::String>,
        pub(crate) pem_encoded_certificate: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The ARN of the certificate authority for the group.
        pub fn group_certificate_authority_arn(
            mut self,
            input: impl Into<std::string::String>,
        ) -> Self {
            self.group_certificate_authority_arn = Some(input.into());
            self
        }
        /// The ARN of the certificate authority for the group.
        pub fn set_group_certificate_authority_arn(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.group_certificate_authority_arn = input;
            self
        }
        /// The ID of the certificate authority for the group.
        pub fn group_certificate_authority_id(
            mut self,
            input: impl Into<std::string::String>,
        ) -> Self {
            self.group_certificate_authority_id = Some(input.into());
            self
        }
        /// The ID of the certificate authority for the group.
        pub fn set_group_certificate_authority_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.group_certificate_authority_id = input;
            self
        }
        /// The PEM encoded certificate for the group.
        pub fn pem_encoded_certificate(mut self, input: impl Into<std::string::String>) -> Self {
            self.pem_encoded_certificate = Some(input.into());
            self
        }
        /// The PEM encoded certificate for the group.
        pub fn set_pem_encoded_certificate(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.pem_encoded_certificate = input;
            self
        }
        /// Consumes the builder and constructs a [`GetGroupCertificateAuthorityOutput`](crate::output::GetGroupCertificateAuthorityOutput).
        pub fn build(self) -> crate::output::GetGroupCertificateAuthorityOutput {
            crate::output::GetGroupCertificateAuthorityOutput {
                group_certificate_authority_arn: self.group_certificate_authority_arn,
                group_certificate_authority_id: self.group_certificate_authority_id,
                pem_encoded_certificate: self.pem_encoded_certificate,
            }
        }
    }
}
impl GetGroupCertificateAuthorityOutput {
    /// Creates a new builder-style object to manufacture [`GetGroupCertificateAuthorityOutput`](crate::output::GetGroupCertificateAuthorityOutput).
    pub fn builder() -> crate::output::get_group_certificate_authority_output::Builder {
        crate::output::get_group_certificate_authority_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetGroupOutput {
    /// The ARN of the definition.
    #[doc(hidden)]
    pub arn: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the definition was created.
    #[doc(hidden)]
    pub creation_timestamp: std::option::Option<std::string::String>,
    /// The ID of the definition.
    #[doc(hidden)]
    pub id: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the definition was last updated.
    #[doc(hidden)]
    pub last_updated_timestamp: std::option::Option<std::string::String>,
    /// The ID of the latest version associated with the definition.
    #[doc(hidden)]
    pub latest_version: std::option::Option<std::string::String>,
    /// The ARN of the latest version associated with the definition.
    #[doc(hidden)]
    pub latest_version_arn: std::option::Option<std::string::String>,
    /// The name of the definition.
    #[doc(hidden)]
    pub name: std::option::Option<std::string::String>,
    /// Tag(s) attached to the resource arn.
    #[doc(hidden)]
    pub tags:
        std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl GetGroupOutput {
    /// The ARN of the definition.
    pub fn arn(&self) -> std::option::Option<&str> {
        self.arn.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the definition was created.
    pub fn creation_timestamp(&self) -> std::option::Option<&str> {
        self.creation_timestamp.as_deref()
    }
    /// The ID of the definition.
    pub fn id(&self) -> std::option::Option<&str> {
        self.id.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the definition was last updated.
    pub fn last_updated_timestamp(&self) -> std::option::Option<&str> {
        self.last_updated_timestamp.as_deref()
    }
    /// The ID of the latest version associated with the definition.
    pub fn latest_version(&self) -> std::option::Option<&str> {
        self.latest_version.as_deref()
    }
    /// The ARN of the latest version associated with the definition.
    pub fn latest_version_arn(&self) -> std::option::Option<&str> {
        self.latest_version_arn.as_deref()
    }
    /// The name of the definition.
    pub fn name(&self) -> std::option::Option<&str> {
        self.name.as_deref()
    }
    /// Tag(s) attached to the resource arn.
    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 GetGroupOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetGroupOutput");
        formatter.field("arn", &self.arn);
        formatter.field("creation_timestamp", &self.creation_timestamp);
        formatter.field("id", &self.id);
        formatter.field("last_updated_timestamp", &self.last_updated_timestamp);
        formatter.field("latest_version", &self.latest_version);
        formatter.field("latest_version_arn", &self.latest_version_arn);
        formatter.field("name", &self.name);
        formatter.field("tags", &self.tags);
        formatter.finish()
    }
}
/// See [`GetGroupOutput`](crate::output::GetGroupOutput).
pub mod get_group_output {

    /// A builder for [`GetGroupOutput`](crate::output::GetGroupOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) arn: std::option::Option<std::string::String>,
        pub(crate) creation_timestamp: std::option::Option<std::string::String>,
        pub(crate) id: std::option::Option<std::string::String>,
        pub(crate) last_updated_timestamp: std::option::Option<std::string::String>,
        pub(crate) latest_version: std::option::Option<std::string::String>,
        pub(crate) latest_version_arn: std::option::Option<std::string::String>,
        pub(crate) name: std::option::Option<std::string::String>,
        pub(crate) tags: std::option::Option<
            std::collections::HashMap<std::string::String, std::string::String>,
        >,
    }
    impl Builder {
        /// The ARN of the definition.
        pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.arn = Some(input.into());
            self
        }
        /// The ARN of the definition.
        pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.arn = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was created.
        pub fn creation_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.creation_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was created.
        pub fn set_creation_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.creation_timestamp = input;
            self
        }
        /// The ID of the definition.
        pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
            self.id = Some(input.into());
            self
        }
        /// The ID of the definition.
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.id = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was last updated.
        pub fn last_updated_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.last_updated_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was last updated.
        pub fn set_last_updated_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.last_updated_timestamp = input;
            self
        }
        /// The ID of the latest version associated with the definition.
        pub fn latest_version(mut self, input: impl Into<std::string::String>) -> Self {
            self.latest_version = Some(input.into());
            self
        }
        /// The ID of the latest version associated with the definition.
        pub fn set_latest_version(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.latest_version = input;
            self
        }
        /// The ARN of the latest version associated with the definition.
        pub fn latest_version_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.latest_version_arn = Some(input.into());
            self
        }
        /// The ARN of the latest version associated with the definition.
        pub fn set_latest_version_arn(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.latest_version_arn = input;
            self
        }
        /// The name of the definition.
        pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
            self.name = Some(input.into());
            self
        }
        /// The name of the definition.
        pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.name = input;
            self
        }
        /// Adds a key-value pair to `tags`.
        ///
        /// To override the contents of this collection use [`set_tags`](Self::set_tags).
        ///
        /// Tag(s) attached to the resource arn.
        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
        }
        /// Tag(s) attached to the resource arn.
        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 [`GetGroupOutput`](crate::output::GetGroupOutput).
        pub fn build(self) -> crate::output::GetGroupOutput {
            crate::output::GetGroupOutput {
                arn: self.arn,
                creation_timestamp: self.creation_timestamp,
                id: self.id,
                last_updated_timestamp: self.last_updated_timestamp,
                latest_version: self.latest_version,
                latest_version_arn: self.latest_version_arn,
                name: self.name,
                tags: self.tags,
            }
        }
    }
}
impl GetGroupOutput {
    /// Creates a new builder-style object to manufacture [`GetGroupOutput`](crate::output::GetGroupOutput).
    pub fn builder() -> crate::output::get_group_output::Builder {
        crate::output::get_group_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetFunctionDefinitionVersionOutput {
    /// The ARN of the function definition version.
    #[doc(hidden)]
    pub arn: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the function definition version was created.
    #[doc(hidden)]
    pub creation_timestamp: std::option::Option<std::string::String>,
    /// Information on the definition.
    #[doc(hidden)]
    pub definition: std::option::Option<crate::model::FunctionDefinitionVersion>,
    /// The ID of the function definition version.
    #[doc(hidden)]
    pub id: std::option::Option<std::string::String>,
    /// The token for the next set of results, or ''null'' if there are no additional results.
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
    /// The version of the function definition version.
    #[doc(hidden)]
    pub version: std::option::Option<std::string::String>,
}
impl GetFunctionDefinitionVersionOutput {
    /// The ARN of the function definition version.
    pub fn arn(&self) -> std::option::Option<&str> {
        self.arn.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the function definition version was created.
    pub fn creation_timestamp(&self) -> std::option::Option<&str> {
        self.creation_timestamp.as_deref()
    }
    /// Information on the definition.
    pub fn definition(&self) -> std::option::Option<&crate::model::FunctionDefinitionVersion> {
        self.definition.as_ref()
    }
    /// The ID of the function definition version.
    pub fn id(&self) -> std::option::Option<&str> {
        self.id.as_deref()
    }
    /// The token for the next set of results, or ''null'' if there are no additional results.
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// The version of the function definition version.
    pub fn version(&self) -> std::option::Option<&str> {
        self.version.as_deref()
    }
}
impl std::fmt::Debug for GetFunctionDefinitionVersionOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetFunctionDefinitionVersionOutput");
        formatter.field("arn", &self.arn);
        formatter.field("creation_timestamp", &self.creation_timestamp);
        formatter.field("definition", &self.definition);
        formatter.field("id", &self.id);
        formatter.field("next_token", &self.next_token);
        formatter.field("version", &self.version);
        formatter.finish()
    }
}
/// See [`GetFunctionDefinitionVersionOutput`](crate::output::GetFunctionDefinitionVersionOutput).
pub mod get_function_definition_version_output {

    /// A builder for [`GetFunctionDefinitionVersionOutput`](crate::output::GetFunctionDefinitionVersionOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) arn: std::option::Option<std::string::String>,
        pub(crate) creation_timestamp: std::option::Option<std::string::String>,
        pub(crate) definition: std::option::Option<crate::model::FunctionDefinitionVersion>,
        pub(crate) id: std::option::Option<std::string::String>,
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) version: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The ARN of the function definition version.
        pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.arn = Some(input.into());
            self
        }
        /// The ARN of the function definition version.
        pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.arn = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the function definition version was created.
        pub fn creation_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.creation_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the function definition version was created.
        pub fn set_creation_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.creation_timestamp = input;
            self
        }
        /// Information on the definition.
        pub fn definition(mut self, input: crate::model::FunctionDefinitionVersion) -> Self {
            self.definition = Some(input);
            self
        }
        /// Information on the definition.
        pub fn set_definition(
            mut self,
            input: std::option::Option<crate::model::FunctionDefinitionVersion>,
        ) -> Self {
            self.definition = input;
            self
        }
        /// The ID of the function definition version.
        pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
            self.id = Some(input.into());
            self
        }
        /// The ID of the function definition version.
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.id = input;
            self
        }
        /// The token for the next set of results, or ''null'' if there are no additional results.
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// The token for the next set of results, or ''null'' if there are no additional results.
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// The version of the function definition version.
        pub fn version(mut self, input: impl Into<std::string::String>) -> Self {
            self.version = Some(input.into());
            self
        }
        /// The version of the function definition version.
        pub fn set_version(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.version = input;
            self
        }
        /// Consumes the builder and constructs a [`GetFunctionDefinitionVersionOutput`](crate::output::GetFunctionDefinitionVersionOutput).
        pub fn build(self) -> crate::output::GetFunctionDefinitionVersionOutput {
            crate::output::GetFunctionDefinitionVersionOutput {
                arn: self.arn,
                creation_timestamp: self.creation_timestamp,
                definition: self.definition,
                id: self.id,
                next_token: self.next_token,
                version: self.version,
            }
        }
    }
}
impl GetFunctionDefinitionVersionOutput {
    /// Creates a new builder-style object to manufacture [`GetFunctionDefinitionVersionOutput`](crate::output::GetFunctionDefinitionVersionOutput).
    pub fn builder() -> crate::output::get_function_definition_version_output::Builder {
        crate::output::get_function_definition_version_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetFunctionDefinitionOutput {
    /// The ARN of the definition.
    #[doc(hidden)]
    pub arn: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the definition was created.
    #[doc(hidden)]
    pub creation_timestamp: std::option::Option<std::string::String>,
    /// The ID of the definition.
    #[doc(hidden)]
    pub id: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the definition was last updated.
    #[doc(hidden)]
    pub last_updated_timestamp: std::option::Option<std::string::String>,
    /// The ID of the latest version associated with the definition.
    #[doc(hidden)]
    pub latest_version: std::option::Option<std::string::String>,
    /// The ARN of the latest version associated with the definition.
    #[doc(hidden)]
    pub latest_version_arn: std::option::Option<std::string::String>,
    /// The name of the definition.
    #[doc(hidden)]
    pub name: std::option::Option<std::string::String>,
    /// Tag(s) attached to the resource arn.
    #[doc(hidden)]
    pub tags:
        std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl GetFunctionDefinitionOutput {
    /// The ARN of the definition.
    pub fn arn(&self) -> std::option::Option<&str> {
        self.arn.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the definition was created.
    pub fn creation_timestamp(&self) -> std::option::Option<&str> {
        self.creation_timestamp.as_deref()
    }
    /// The ID of the definition.
    pub fn id(&self) -> std::option::Option<&str> {
        self.id.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the definition was last updated.
    pub fn last_updated_timestamp(&self) -> std::option::Option<&str> {
        self.last_updated_timestamp.as_deref()
    }
    /// The ID of the latest version associated with the definition.
    pub fn latest_version(&self) -> std::option::Option<&str> {
        self.latest_version.as_deref()
    }
    /// The ARN of the latest version associated with the definition.
    pub fn latest_version_arn(&self) -> std::option::Option<&str> {
        self.latest_version_arn.as_deref()
    }
    /// The name of the definition.
    pub fn name(&self) -> std::option::Option<&str> {
        self.name.as_deref()
    }
    /// Tag(s) attached to the resource arn.
    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 GetFunctionDefinitionOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetFunctionDefinitionOutput");
        formatter.field("arn", &self.arn);
        formatter.field("creation_timestamp", &self.creation_timestamp);
        formatter.field("id", &self.id);
        formatter.field("last_updated_timestamp", &self.last_updated_timestamp);
        formatter.field("latest_version", &self.latest_version);
        formatter.field("latest_version_arn", &self.latest_version_arn);
        formatter.field("name", &self.name);
        formatter.field("tags", &self.tags);
        formatter.finish()
    }
}
/// See [`GetFunctionDefinitionOutput`](crate::output::GetFunctionDefinitionOutput).
pub mod get_function_definition_output {

    /// A builder for [`GetFunctionDefinitionOutput`](crate::output::GetFunctionDefinitionOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) arn: std::option::Option<std::string::String>,
        pub(crate) creation_timestamp: std::option::Option<std::string::String>,
        pub(crate) id: std::option::Option<std::string::String>,
        pub(crate) last_updated_timestamp: std::option::Option<std::string::String>,
        pub(crate) latest_version: std::option::Option<std::string::String>,
        pub(crate) latest_version_arn: std::option::Option<std::string::String>,
        pub(crate) name: std::option::Option<std::string::String>,
        pub(crate) tags: std::option::Option<
            std::collections::HashMap<std::string::String, std::string::String>,
        >,
    }
    impl Builder {
        /// The ARN of the definition.
        pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.arn = Some(input.into());
            self
        }
        /// The ARN of the definition.
        pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.arn = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was created.
        pub fn creation_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.creation_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was created.
        pub fn set_creation_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.creation_timestamp = input;
            self
        }
        /// The ID of the definition.
        pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
            self.id = Some(input.into());
            self
        }
        /// The ID of the definition.
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.id = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was last updated.
        pub fn last_updated_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.last_updated_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was last updated.
        pub fn set_last_updated_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.last_updated_timestamp = input;
            self
        }
        /// The ID of the latest version associated with the definition.
        pub fn latest_version(mut self, input: impl Into<std::string::String>) -> Self {
            self.latest_version = Some(input.into());
            self
        }
        /// The ID of the latest version associated with the definition.
        pub fn set_latest_version(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.latest_version = input;
            self
        }
        /// The ARN of the latest version associated with the definition.
        pub fn latest_version_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.latest_version_arn = Some(input.into());
            self
        }
        /// The ARN of the latest version associated with the definition.
        pub fn set_latest_version_arn(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.latest_version_arn = input;
            self
        }
        /// The name of the definition.
        pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
            self.name = Some(input.into());
            self
        }
        /// The name of the definition.
        pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.name = input;
            self
        }
        /// Adds a key-value pair to `tags`.
        ///
        /// To override the contents of this collection use [`set_tags`](Self::set_tags).
        ///
        /// Tag(s) attached to the resource arn.
        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
        }
        /// Tag(s) attached to the resource arn.
        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 [`GetFunctionDefinitionOutput`](crate::output::GetFunctionDefinitionOutput).
        pub fn build(self) -> crate::output::GetFunctionDefinitionOutput {
            crate::output::GetFunctionDefinitionOutput {
                arn: self.arn,
                creation_timestamp: self.creation_timestamp,
                id: self.id,
                last_updated_timestamp: self.last_updated_timestamp,
                latest_version: self.latest_version,
                latest_version_arn: self.latest_version_arn,
                name: self.name,
                tags: self.tags,
            }
        }
    }
}
impl GetFunctionDefinitionOutput {
    /// Creates a new builder-style object to manufacture [`GetFunctionDefinitionOutput`](crate::output::GetFunctionDefinitionOutput).
    pub fn builder() -> crate::output::get_function_definition_output::Builder {
        crate::output::get_function_definition_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetDeviceDefinitionVersionOutput {
    /// The ARN of the device definition version.
    #[doc(hidden)]
    pub arn: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the device definition version was created.
    #[doc(hidden)]
    pub creation_timestamp: std::option::Option<std::string::String>,
    /// Information about the device definition version.
    #[doc(hidden)]
    pub definition: std::option::Option<crate::model::DeviceDefinitionVersion>,
    /// The ID of the device definition version.
    #[doc(hidden)]
    pub id: std::option::Option<std::string::String>,
    /// The token for the next set of results, or ''null'' if there are no additional results.
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
    /// The version of the device definition version.
    #[doc(hidden)]
    pub version: std::option::Option<std::string::String>,
}
impl GetDeviceDefinitionVersionOutput {
    /// The ARN of the device definition version.
    pub fn arn(&self) -> std::option::Option<&str> {
        self.arn.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the device definition version was created.
    pub fn creation_timestamp(&self) -> std::option::Option<&str> {
        self.creation_timestamp.as_deref()
    }
    /// Information about the device definition version.
    pub fn definition(&self) -> std::option::Option<&crate::model::DeviceDefinitionVersion> {
        self.definition.as_ref()
    }
    /// The ID of the device definition version.
    pub fn id(&self) -> std::option::Option<&str> {
        self.id.as_deref()
    }
    /// The token for the next set of results, or ''null'' if there are no additional results.
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// The version of the device definition version.
    pub fn version(&self) -> std::option::Option<&str> {
        self.version.as_deref()
    }
}
impl std::fmt::Debug for GetDeviceDefinitionVersionOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetDeviceDefinitionVersionOutput");
        formatter.field("arn", &self.arn);
        formatter.field("creation_timestamp", &self.creation_timestamp);
        formatter.field("definition", &self.definition);
        formatter.field("id", &self.id);
        formatter.field("next_token", &self.next_token);
        formatter.field("version", &self.version);
        formatter.finish()
    }
}
/// See [`GetDeviceDefinitionVersionOutput`](crate::output::GetDeviceDefinitionVersionOutput).
pub mod get_device_definition_version_output {

    /// A builder for [`GetDeviceDefinitionVersionOutput`](crate::output::GetDeviceDefinitionVersionOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) arn: std::option::Option<std::string::String>,
        pub(crate) creation_timestamp: std::option::Option<std::string::String>,
        pub(crate) definition: std::option::Option<crate::model::DeviceDefinitionVersion>,
        pub(crate) id: std::option::Option<std::string::String>,
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) version: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The ARN of the device definition version.
        pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.arn = Some(input.into());
            self
        }
        /// The ARN of the device definition version.
        pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.arn = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the device definition version was created.
        pub fn creation_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.creation_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the device definition version was created.
        pub fn set_creation_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.creation_timestamp = input;
            self
        }
        /// Information about the device definition version.
        pub fn definition(mut self, input: crate::model::DeviceDefinitionVersion) -> Self {
            self.definition = Some(input);
            self
        }
        /// Information about the device definition version.
        pub fn set_definition(
            mut self,
            input: std::option::Option<crate::model::DeviceDefinitionVersion>,
        ) -> Self {
            self.definition = input;
            self
        }
        /// The ID of the device definition version.
        pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
            self.id = Some(input.into());
            self
        }
        /// The ID of the device definition version.
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.id = input;
            self
        }
        /// The token for the next set of results, or ''null'' if there are no additional results.
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// The token for the next set of results, or ''null'' if there are no additional results.
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// The version of the device definition version.
        pub fn version(mut self, input: impl Into<std::string::String>) -> Self {
            self.version = Some(input.into());
            self
        }
        /// The version of the device definition version.
        pub fn set_version(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.version = input;
            self
        }
        /// Consumes the builder and constructs a [`GetDeviceDefinitionVersionOutput`](crate::output::GetDeviceDefinitionVersionOutput).
        pub fn build(self) -> crate::output::GetDeviceDefinitionVersionOutput {
            crate::output::GetDeviceDefinitionVersionOutput {
                arn: self.arn,
                creation_timestamp: self.creation_timestamp,
                definition: self.definition,
                id: self.id,
                next_token: self.next_token,
                version: self.version,
            }
        }
    }
}
impl GetDeviceDefinitionVersionOutput {
    /// Creates a new builder-style object to manufacture [`GetDeviceDefinitionVersionOutput`](crate::output::GetDeviceDefinitionVersionOutput).
    pub fn builder() -> crate::output::get_device_definition_version_output::Builder {
        crate::output::get_device_definition_version_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetDeviceDefinitionOutput {
    /// The ARN of the definition.
    #[doc(hidden)]
    pub arn: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the definition was created.
    #[doc(hidden)]
    pub creation_timestamp: std::option::Option<std::string::String>,
    /// The ID of the definition.
    #[doc(hidden)]
    pub id: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the definition was last updated.
    #[doc(hidden)]
    pub last_updated_timestamp: std::option::Option<std::string::String>,
    /// The ID of the latest version associated with the definition.
    #[doc(hidden)]
    pub latest_version: std::option::Option<std::string::String>,
    /// The ARN of the latest version associated with the definition.
    #[doc(hidden)]
    pub latest_version_arn: std::option::Option<std::string::String>,
    /// The name of the definition.
    #[doc(hidden)]
    pub name: std::option::Option<std::string::String>,
    /// Tag(s) attached to the resource arn.
    #[doc(hidden)]
    pub tags:
        std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl GetDeviceDefinitionOutput {
    /// The ARN of the definition.
    pub fn arn(&self) -> std::option::Option<&str> {
        self.arn.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the definition was created.
    pub fn creation_timestamp(&self) -> std::option::Option<&str> {
        self.creation_timestamp.as_deref()
    }
    /// The ID of the definition.
    pub fn id(&self) -> std::option::Option<&str> {
        self.id.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the definition was last updated.
    pub fn last_updated_timestamp(&self) -> std::option::Option<&str> {
        self.last_updated_timestamp.as_deref()
    }
    /// The ID of the latest version associated with the definition.
    pub fn latest_version(&self) -> std::option::Option<&str> {
        self.latest_version.as_deref()
    }
    /// The ARN of the latest version associated with the definition.
    pub fn latest_version_arn(&self) -> std::option::Option<&str> {
        self.latest_version_arn.as_deref()
    }
    /// The name of the definition.
    pub fn name(&self) -> std::option::Option<&str> {
        self.name.as_deref()
    }
    /// Tag(s) attached to the resource arn.
    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 GetDeviceDefinitionOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetDeviceDefinitionOutput");
        formatter.field("arn", &self.arn);
        formatter.field("creation_timestamp", &self.creation_timestamp);
        formatter.field("id", &self.id);
        formatter.field("last_updated_timestamp", &self.last_updated_timestamp);
        formatter.field("latest_version", &self.latest_version);
        formatter.field("latest_version_arn", &self.latest_version_arn);
        formatter.field("name", &self.name);
        formatter.field("tags", &self.tags);
        formatter.finish()
    }
}
/// See [`GetDeviceDefinitionOutput`](crate::output::GetDeviceDefinitionOutput).
pub mod get_device_definition_output {

    /// A builder for [`GetDeviceDefinitionOutput`](crate::output::GetDeviceDefinitionOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) arn: std::option::Option<std::string::String>,
        pub(crate) creation_timestamp: std::option::Option<std::string::String>,
        pub(crate) id: std::option::Option<std::string::String>,
        pub(crate) last_updated_timestamp: std::option::Option<std::string::String>,
        pub(crate) latest_version: std::option::Option<std::string::String>,
        pub(crate) latest_version_arn: std::option::Option<std::string::String>,
        pub(crate) name: std::option::Option<std::string::String>,
        pub(crate) tags: std::option::Option<
            std::collections::HashMap<std::string::String, std::string::String>,
        >,
    }
    impl Builder {
        /// The ARN of the definition.
        pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.arn = Some(input.into());
            self
        }
        /// The ARN of the definition.
        pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.arn = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was created.
        pub fn creation_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.creation_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was created.
        pub fn set_creation_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.creation_timestamp = input;
            self
        }
        /// The ID of the definition.
        pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
            self.id = Some(input.into());
            self
        }
        /// The ID of the definition.
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.id = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was last updated.
        pub fn last_updated_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.last_updated_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was last updated.
        pub fn set_last_updated_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.last_updated_timestamp = input;
            self
        }
        /// The ID of the latest version associated with the definition.
        pub fn latest_version(mut self, input: impl Into<std::string::String>) -> Self {
            self.latest_version = Some(input.into());
            self
        }
        /// The ID of the latest version associated with the definition.
        pub fn set_latest_version(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.latest_version = input;
            self
        }
        /// The ARN of the latest version associated with the definition.
        pub fn latest_version_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.latest_version_arn = Some(input.into());
            self
        }
        /// The ARN of the latest version associated with the definition.
        pub fn set_latest_version_arn(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.latest_version_arn = input;
            self
        }
        /// The name of the definition.
        pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
            self.name = Some(input.into());
            self
        }
        /// The name of the definition.
        pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.name = input;
            self
        }
        /// Adds a key-value pair to `tags`.
        ///
        /// To override the contents of this collection use [`set_tags`](Self::set_tags).
        ///
        /// Tag(s) attached to the resource arn.
        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
        }
        /// Tag(s) attached to the resource arn.
        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 [`GetDeviceDefinitionOutput`](crate::output::GetDeviceDefinitionOutput).
        pub fn build(self) -> crate::output::GetDeviceDefinitionOutput {
            crate::output::GetDeviceDefinitionOutput {
                arn: self.arn,
                creation_timestamp: self.creation_timestamp,
                id: self.id,
                last_updated_timestamp: self.last_updated_timestamp,
                latest_version: self.latest_version,
                latest_version_arn: self.latest_version_arn,
                name: self.name,
                tags: self.tags,
            }
        }
    }
}
impl GetDeviceDefinitionOutput {
    /// Creates a new builder-style object to manufacture [`GetDeviceDefinitionOutput`](crate::output::GetDeviceDefinitionOutput).
    pub fn builder() -> crate::output::get_device_definition_output::Builder {
        crate::output::get_device_definition_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetDeploymentStatusOutput {
    /// The status of the deployment: ''InProgress'', ''Building'', ''Success'', or ''Failure''.
    #[doc(hidden)]
    pub deployment_status: std::option::Option<std::string::String>,
    /// The type of the deployment.
    #[doc(hidden)]
    pub deployment_type: std::option::Option<crate::model::DeploymentType>,
    /// Error details
    #[doc(hidden)]
    pub error_details: std::option::Option<std::vec::Vec<crate::model::ErrorDetail>>,
    /// Error message
    #[doc(hidden)]
    pub error_message: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the deployment status was updated.
    #[doc(hidden)]
    pub updated_at: std::option::Option<std::string::String>,
}
impl GetDeploymentStatusOutput {
    /// The status of the deployment: ''InProgress'', ''Building'', ''Success'', or ''Failure''.
    pub fn deployment_status(&self) -> std::option::Option<&str> {
        self.deployment_status.as_deref()
    }
    /// The type of the deployment.
    pub fn deployment_type(&self) -> std::option::Option<&crate::model::DeploymentType> {
        self.deployment_type.as_ref()
    }
    /// Error details
    pub fn error_details(&self) -> std::option::Option<&[crate::model::ErrorDetail]> {
        self.error_details.as_deref()
    }
    /// Error message
    pub fn error_message(&self) -> std::option::Option<&str> {
        self.error_message.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the deployment status was updated.
    pub fn updated_at(&self) -> std::option::Option<&str> {
        self.updated_at.as_deref()
    }
}
impl std::fmt::Debug for GetDeploymentStatusOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetDeploymentStatusOutput");
        formatter.field("deployment_status", &self.deployment_status);
        formatter.field("deployment_type", &self.deployment_type);
        formatter.field("error_details", &self.error_details);
        formatter.field("error_message", &self.error_message);
        formatter.field("updated_at", &self.updated_at);
        formatter.finish()
    }
}
/// See [`GetDeploymentStatusOutput`](crate::output::GetDeploymentStatusOutput).
pub mod get_deployment_status_output {

    /// A builder for [`GetDeploymentStatusOutput`](crate::output::GetDeploymentStatusOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) deployment_status: std::option::Option<std::string::String>,
        pub(crate) deployment_type: std::option::Option<crate::model::DeploymentType>,
        pub(crate) error_details: std::option::Option<std::vec::Vec<crate::model::ErrorDetail>>,
        pub(crate) error_message: std::option::Option<std::string::String>,
        pub(crate) updated_at: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The status of the deployment: ''InProgress'', ''Building'', ''Success'', or ''Failure''.
        pub fn deployment_status(mut self, input: impl Into<std::string::String>) -> Self {
            self.deployment_status = Some(input.into());
            self
        }
        /// The status of the deployment: ''InProgress'', ''Building'', ''Success'', or ''Failure''.
        pub fn set_deployment_status(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.deployment_status = input;
            self
        }
        /// The type of the deployment.
        pub fn deployment_type(mut self, input: crate::model::DeploymentType) -> Self {
            self.deployment_type = Some(input);
            self
        }
        /// The type of the deployment.
        pub fn set_deployment_type(
            mut self,
            input: std::option::Option<crate::model::DeploymentType>,
        ) -> Self {
            self.deployment_type = input;
            self
        }
        /// Appends an item to `error_details`.
        ///
        /// To override the contents of this collection use [`set_error_details`](Self::set_error_details).
        ///
        /// Error details
        pub fn error_details(mut self, input: crate::model::ErrorDetail) -> Self {
            let mut v = self.error_details.unwrap_or_default();
            v.push(input);
            self.error_details = Some(v);
            self
        }
        /// Error details
        pub fn set_error_details(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ErrorDetail>>,
        ) -> Self {
            self.error_details = input;
            self
        }
        /// Error message
        pub fn error_message(mut self, input: impl Into<std::string::String>) -> Self {
            self.error_message = Some(input.into());
            self
        }
        /// Error message
        pub fn set_error_message(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.error_message = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the deployment status was updated.
        pub fn updated_at(mut self, input: impl Into<std::string::String>) -> Self {
            self.updated_at = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the deployment status was updated.
        pub fn set_updated_at(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.updated_at = input;
            self
        }
        /// Consumes the builder and constructs a [`GetDeploymentStatusOutput`](crate::output::GetDeploymentStatusOutput).
        pub fn build(self) -> crate::output::GetDeploymentStatusOutput {
            crate::output::GetDeploymentStatusOutput {
                deployment_status: self.deployment_status,
                deployment_type: self.deployment_type,
                error_details: self.error_details,
                error_message: self.error_message,
                updated_at: self.updated_at,
            }
        }
    }
}
impl GetDeploymentStatusOutput {
    /// Creates a new builder-style object to manufacture [`GetDeploymentStatusOutput`](crate::output::GetDeploymentStatusOutput).
    pub fn builder() -> crate::output::get_deployment_status_output::Builder {
        crate::output::get_deployment_status_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetCoreDefinitionVersionOutput {
    /// The ARN of the core definition version.
    #[doc(hidden)]
    pub arn: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the core definition version was created.
    #[doc(hidden)]
    pub creation_timestamp: std::option::Option<std::string::String>,
    /// Information about the core definition version.
    #[doc(hidden)]
    pub definition: std::option::Option<crate::model::CoreDefinitionVersion>,
    /// The ID of the core definition version.
    #[doc(hidden)]
    pub id: std::option::Option<std::string::String>,
    /// The token for the next set of results, or ''null'' if there are no additional results.
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
    /// The version of the core definition version.
    #[doc(hidden)]
    pub version: std::option::Option<std::string::String>,
}
impl GetCoreDefinitionVersionOutput {
    /// The ARN of the core definition version.
    pub fn arn(&self) -> std::option::Option<&str> {
        self.arn.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the core definition version was created.
    pub fn creation_timestamp(&self) -> std::option::Option<&str> {
        self.creation_timestamp.as_deref()
    }
    /// Information about the core definition version.
    pub fn definition(&self) -> std::option::Option<&crate::model::CoreDefinitionVersion> {
        self.definition.as_ref()
    }
    /// The ID of the core definition version.
    pub fn id(&self) -> std::option::Option<&str> {
        self.id.as_deref()
    }
    /// The token for the next set of results, or ''null'' if there are no additional results.
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// The version of the core definition version.
    pub fn version(&self) -> std::option::Option<&str> {
        self.version.as_deref()
    }
}
impl std::fmt::Debug for GetCoreDefinitionVersionOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetCoreDefinitionVersionOutput");
        formatter.field("arn", &self.arn);
        formatter.field("creation_timestamp", &self.creation_timestamp);
        formatter.field("definition", &self.definition);
        formatter.field("id", &self.id);
        formatter.field("next_token", &self.next_token);
        formatter.field("version", &self.version);
        formatter.finish()
    }
}
/// See [`GetCoreDefinitionVersionOutput`](crate::output::GetCoreDefinitionVersionOutput).
pub mod get_core_definition_version_output {

    /// A builder for [`GetCoreDefinitionVersionOutput`](crate::output::GetCoreDefinitionVersionOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) arn: std::option::Option<std::string::String>,
        pub(crate) creation_timestamp: std::option::Option<std::string::String>,
        pub(crate) definition: std::option::Option<crate::model::CoreDefinitionVersion>,
        pub(crate) id: std::option::Option<std::string::String>,
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) version: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The ARN of the core definition version.
        pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.arn = Some(input.into());
            self
        }
        /// The ARN of the core definition version.
        pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.arn = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the core definition version was created.
        pub fn creation_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.creation_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the core definition version was created.
        pub fn set_creation_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.creation_timestamp = input;
            self
        }
        /// Information about the core definition version.
        pub fn definition(mut self, input: crate::model::CoreDefinitionVersion) -> Self {
            self.definition = Some(input);
            self
        }
        /// Information about the core definition version.
        pub fn set_definition(
            mut self,
            input: std::option::Option<crate::model::CoreDefinitionVersion>,
        ) -> Self {
            self.definition = input;
            self
        }
        /// The ID of the core definition version.
        pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
            self.id = Some(input.into());
            self
        }
        /// The ID of the core definition version.
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.id = input;
            self
        }
        /// The token for the next set of results, or ''null'' if there are no additional results.
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// The token for the next set of results, or ''null'' if there are no additional results.
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// The version of the core definition version.
        pub fn version(mut self, input: impl Into<std::string::String>) -> Self {
            self.version = Some(input.into());
            self
        }
        /// The version of the core definition version.
        pub fn set_version(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.version = input;
            self
        }
        /// Consumes the builder and constructs a [`GetCoreDefinitionVersionOutput`](crate::output::GetCoreDefinitionVersionOutput).
        pub fn build(self) -> crate::output::GetCoreDefinitionVersionOutput {
            crate::output::GetCoreDefinitionVersionOutput {
                arn: self.arn,
                creation_timestamp: self.creation_timestamp,
                definition: self.definition,
                id: self.id,
                next_token: self.next_token,
                version: self.version,
            }
        }
    }
}
impl GetCoreDefinitionVersionOutput {
    /// Creates a new builder-style object to manufacture [`GetCoreDefinitionVersionOutput`](crate::output::GetCoreDefinitionVersionOutput).
    pub fn builder() -> crate::output::get_core_definition_version_output::Builder {
        crate::output::get_core_definition_version_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetCoreDefinitionOutput {
    /// The ARN of the definition.
    #[doc(hidden)]
    pub arn: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the definition was created.
    #[doc(hidden)]
    pub creation_timestamp: std::option::Option<std::string::String>,
    /// The ID of the definition.
    #[doc(hidden)]
    pub id: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the definition was last updated.
    #[doc(hidden)]
    pub last_updated_timestamp: std::option::Option<std::string::String>,
    /// The ID of the latest version associated with the definition.
    #[doc(hidden)]
    pub latest_version: std::option::Option<std::string::String>,
    /// The ARN of the latest version associated with the definition.
    #[doc(hidden)]
    pub latest_version_arn: std::option::Option<std::string::String>,
    /// The name of the definition.
    #[doc(hidden)]
    pub name: std::option::Option<std::string::String>,
    /// Tag(s) attached to the resource arn.
    #[doc(hidden)]
    pub tags:
        std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl GetCoreDefinitionOutput {
    /// The ARN of the definition.
    pub fn arn(&self) -> std::option::Option<&str> {
        self.arn.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the definition was created.
    pub fn creation_timestamp(&self) -> std::option::Option<&str> {
        self.creation_timestamp.as_deref()
    }
    /// The ID of the definition.
    pub fn id(&self) -> std::option::Option<&str> {
        self.id.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the definition was last updated.
    pub fn last_updated_timestamp(&self) -> std::option::Option<&str> {
        self.last_updated_timestamp.as_deref()
    }
    /// The ID of the latest version associated with the definition.
    pub fn latest_version(&self) -> std::option::Option<&str> {
        self.latest_version.as_deref()
    }
    /// The ARN of the latest version associated with the definition.
    pub fn latest_version_arn(&self) -> std::option::Option<&str> {
        self.latest_version_arn.as_deref()
    }
    /// The name of the definition.
    pub fn name(&self) -> std::option::Option<&str> {
        self.name.as_deref()
    }
    /// Tag(s) attached to the resource arn.
    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 GetCoreDefinitionOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetCoreDefinitionOutput");
        formatter.field("arn", &self.arn);
        formatter.field("creation_timestamp", &self.creation_timestamp);
        formatter.field("id", &self.id);
        formatter.field("last_updated_timestamp", &self.last_updated_timestamp);
        formatter.field("latest_version", &self.latest_version);
        formatter.field("latest_version_arn", &self.latest_version_arn);
        formatter.field("name", &self.name);
        formatter.field("tags", &self.tags);
        formatter.finish()
    }
}
/// See [`GetCoreDefinitionOutput`](crate::output::GetCoreDefinitionOutput).
pub mod get_core_definition_output {

    /// A builder for [`GetCoreDefinitionOutput`](crate::output::GetCoreDefinitionOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) arn: std::option::Option<std::string::String>,
        pub(crate) creation_timestamp: std::option::Option<std::string::String>,
        pub(crate) id: std::option::Option<std::string::String>,
        pub(crate) last_updated_timestamp: std::option::Option<std::string::String>,
        pub(crate) latest_version: std::option::Option<std::string::String>,
        pub(crate) latest_version_arn: std::option::Option<std::string::String>,
        pub(crate) name: std::option::Option<std::string::String>,
        pub(crate) tags: std::option::Option<
            std::collections::HashMap<std::string::String, std::string::String>,
        >,
    }
    impl Builder {
        /// The ARN of the definition.
        pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.arn = Some(input.into());
            self
        }
        /// The ARN of the definition.
        pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.arn = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was created.
        pub fn creation_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.creation_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was created.
        pub fn set_creation_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.creation_timestamp = input;
            self
        }
        /// The ID of the definition.
        pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
            self.id = Some(input.into());
            self
        }
        /// The ID of the definition.
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.id = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was last updated.
        pub fn last_updated_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.last_updated_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was last updated.
        pub fn set_last_updated_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.last_updated_timestamp = input;
            self
        }
        /// The ID of the latest version associated with the definition.
        pub fn latest_version(mut self, input: impl Into<std::string::String>) -> Self {
            self.latest_version = Some(input.into());
            self
        }
        /// The ID of the latest version associated with the definition.
        pub fn set_latest_version(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.latest_version = input;
            self
        }
        /// The ARN of the latest version associated with the definition.
        pub fn latest_version_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.latest_version_arn = Some(input.into());
            self
        }
        /// The ARN of the latest version associated with the definition.
        pub fn set_latest_version_arn(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.latest_version_arn = input;
            self
        }
        /// The name of the definition.
        pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
            self.name = Some(input.into());
            self
        }
        /// The name of the definition.
        pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.name = input;
            self
        }
        /// Adds a key-value pair to `tags`.
        ///
        /// To override the contents of this collection use [`set_tags`](Self::set_tags).
        ///
        /// Tag(s) attached to the resource arn.
        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
        }
        /// Tag(s) attached to the resource arn.
        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 [`GetCoreDefinitionOutput`](crate::output::GetCoreDefinitionOutput).
        pub fn build(self) -> crate::output::GetCoreDefinitionOutput {
            crate::output::GetCoreDefinitionOutput {
                arn: self.arn,
                creation_timestamp: self.creation_timestamp,
                id: self.id,
                last_updated_timestamp: self.last_updated_timestamp,
                latest_version: self.latest_version,
                latest_version_arn: self.latest_version_arn,
                name: self.name,
                tags: self.tags,
            }
        }
    }
}
impl GetCoreDefinitionOutput {
    /// Creates a new builder-style object to manufacture [`GetCoreDefinitionOutput`](crate::output::GetCoreDefinitionOutput).
    pub fn builder() -> crate::output::get_core_definition_output::Builder {
        crate::output::get_core_definition_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetConnectorDefinitionVersionOutput {
    /// The ARN of the connector definition version.
    #[doc(hidden)]
    pub arn: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the connector definition version was created.
    #[doc(hidden)]
    pub creation_timestamp: std::option::Option<std::string::String>,
    /// Information about the connector definition version.
    #[doc(hidden)]
    pub definition: std::option::Option<crate::model::ConnectorDefinitionVersion>,
    /// The ID of the connector definition version.
    #[doc(hidden)]
    pub id: std::option::Option<std::string::String>,
    /// The token for the next set of results, or ''null'' if there are no additional results.
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
    /// The version of the connector definition version.
    #[doc(hidden)]
    pub version: std::option::Option<std::string::String>,
}
impl GetConnectorDefinitionVersionOutput {
    /// The ARN of the connector definition version.
    pub fn arn(&self) -> std::option::Option<&str> {
        self.arn.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the connector definition version was created.
    pub fn creation_timestamp(&self) -> std::option::Option<&str> {
        self.creation_timestamp.as_deref()
    }
    /// Information about the connector definition version.
    pub fn definition(&self) -> std::option::Option<&crate::model::ConnectorDefinitionVersion> {
        self.definition.as_ref()
    }
    /// The ID of the connector definition version.
    pub fn id(&self) -> std::option::Option<&str> {
        self.id.as_deref()
    }
    /// The token for the next set of results, or ''null'' if there are no additional results.
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// The version of the connector definition version.
    pub fn version(&self) -> std::option::Option<&str> {
        self.version.as_deref()
    }
}
impl std::fmt::Debug for GetConnectorDefinitionVersionOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetConnectorDefinitionVersionOutput");
        formatter.field("arn", &self.arn);
        formatter.field("creation_timestamp", &self.creation_timestamp);
        formatter.field("definition", &self.definition);
        formatter.field("id", &self.id);
        formatter.field("next_token", &self.next_token);
        formatter.field("version", &self.version);
        formatter.finish()
    }
}
/// See [`GetConnectorDefinitionVersionOutput`](crate::output::GetConnectorDefinitionVersionOutput).
pub mod get_connector_definition_version_output {

    /// A builder for [`GetConnectorDefinitionVersionOutput`](crate::output::GetConnectorDefinitionVersionOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) arn: std::option::Option<std::string::String>,
        pub(crate) creation_timestamp: std::option::Option<std::string::String>,
        pub(crate) definition: std::option::Option<crate::model::ConnectorDefinitionVersion>,
        pub(crate) id: std::option::Option<std::string::String>,
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) version: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The ARN of the connector definition version.
        pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.arn = Some(input.into());
            self
        }
        /// The ARN of the connector definition version.
        pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.arn = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the connector definition version was created.
        pub fn creation_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.creation_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the connector definition version was created.
        pub fn set_creation_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.creation_timestamp = input;
            self
        }
        /// Information about the connector definition version.
        pub fn definition(mut self, input: crate::model::ConnectorDefinitionVersion) -> Self {
            self.definition = Some(input);
            self
        }
        /// Information about the connector definition version.
        pub fn set_definition(
            mut self,
            input: std::option::Option<crate::model::ConnectorDefinitionVersion>,
        ) -> Self {
            self.definition = input;
            self
        }
        /// The ID of the connector definition version.
        pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
            self.id = Some(input.into());
            self
        }
        /// The ID of the connector definition version.
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.id = input;
            self
        }
        /// The token for the next set of results, or ''null'' if there are no additional results.
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// The token for the next set of results, or ''null'' if there are no additional results.
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// The version of the connector definition version.
        pub fn version(mut self, input: impl Into<std::string::String>) -> Self {
            self.version = Some(input.into());
            self
        }
        /// The version of the connector definition version.
        pub fn set_version(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.version = input;
            self
        }
        /// Consumes the builder and constructs a [`GetConnectorDefinitionVersionOutput`](crate::output::GetConnectorDefinitionVersionOutput).
        pub fn build(self) -> crate::output::GetConnectorDefinitionVersionOutput {
            crate::output::GetConnectorDefinitionVersionOutput {
                arn: self.arn,
                creation_timestamp: self.creation_timestamp,
                definition: self.definition,
                id: self.id,
                next_token: self.next_token,
                version: self.version,
            }
        }
    }
}
impl GetConnectorDefinitionVersionOutput {
    /// Creates a new builder-style object to manufacture [`GetConnectorDefinitionVersionOutput`](crate::output::GetConnectorDefinitionVersionOutput).
    pub fn builder() -> crate::output::get_connector_definition_version_output::Builder {
        crate::output::get_connector_definition_version_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetConnectorDefinitionOutput {
    /// The ARN of the definition.
    #[doc(hidden)]
    pub arn: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the definition was created.
    #[doc(hidden)]
    pub creation_timestamp: std::option::Option<std::string::String>,
    /// The ID of the definition.
    #[doc(hidden)]
    pub id: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the definition was last updated.
    #[doc(hidden)]
    pub last_updated_timestamp: std::option::Option<std::string::String>,
    /// The ID of the latest version associated with the definition.
    #[doc(hidden)]
    pub latest_version: std::option::Option<std::string::String>,
    /// The ARN of the latest version associated with the definition.
    #[doc(hidden)]
    pub latest_version_arn: std::option::Option<std::string::String>,
    /// The name of the definition.
    #[doc(hidden)]
    pub name: std::option::Option<std::string::String>,
    /// Tag(s) attached to the resource arn.
    #[doc(hidden)]
    pub tags:
        std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl GetConnectorDefinitionOutput {
    /// The ARN of the definition.
    pub fn arn(&self) -> std::option::Option<&str> {
        self.arn.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the definition was created.
    pub fn creation_timestamp(&self) -> std::option::Option<&str> {
        self.creation_timestamp.as_deref()
    }
    /// The ID of the definition.
    pub fn id(&self) -> std::option::Option<&str> {
        self.id.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the definition was last updated.
    pub fn last_updated_timestamp(&self) -> std::option::Option<&str> {
        self.last_updated_timestamp.as_deref()
    }
    /// The ID of the latest version associated with the definition.
    pub fn latest_version(&self) -> std::option::Option<&str> {
        self.latest_version.as_deref()
    }
    /// The ARN of the latest version associated with the definition.
    pub fn latest_version_arn(&self) -> std::option::Option<&str> {
        self.latest_version_arn.as_deref()
    }
    /// The name of the definition.
    pub fn name(&self) -> std::option::Option<&str> {
        self.name.as_deref()
    }
    /// Tag(s) attached to the resource arn.
    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 GetConnectorDefinitionOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetConnectorDefinitionOutput");
        formatter.field("arn", &self.arn);
        formatter.field("creation_timestamp", &self.creation_timestamp);
        formatter.field("id", &self.id);
        formatter.field("last_updated_timestamp", &self.last_updated_timestamp);
        formatter.field("latest_version", &self.latest_version);
        formatter.field("latest_version_arn", &self.latest_version_arn);
        formatter.field("name", &self.name);
        formatter.field("tags", &self.tags);
        formatter.finish()
    }
}
/// See [`GetConnectorDefinitionOutput`](crate::output::GetConnectorDefinitionOutput).
pub mod get_connector_definition_output {

    /// A builder for [`GetConnectorDefinitionOutput`](crate::output::GetConnectorDefinitionOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) arn: std::option::Option<std::string::String>,
        pub(crate) creation_timestamp: std::option::Option<std::string::String>,
        pub(crate) id: std::option::Option<std::string::String>,
        pub(crate) last_updated_timestamp: std::option::Option<std::string::String>,
        pub(crate) latest_version: std::option::Option<std::string::String>,
        pub(crate) latest_version_arn: std::option::Option<std::string::String>,
        pub(crate) name: std::option::Option<std::string::String>,
        pub(crate) tags: std::option::Option<
            std::collections::HashMap<std::string::String, std::string::String>,
        >,
    }
    impl Builder {
        /// The ARN of the definition.
        pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.arn = Some(input.into());
            self
        }
        /// The ARN of the definition.
        pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.arn = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was created.
        pub fn creation_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.creation_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was created.
        pub fn set_creation_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.creation_timestamp = input;
            self
        }
        /// The ID of the definition.
        pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
            self.id = Some(input.into());
            self
        }
        /// The ID of the definition.
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.id = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was last updated.
        pub fn last_updated_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.last_updated_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was last updated.
        pub fn set_last_updated_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.last_updated_timestamp = input;
            self
        }
        /// The ID of the latest version associated with the definition.
        pub fn latest_version(mut self, input: impl Into<std::string::String>) -> Self {
            self.latest_version = Some(input.into());
            self
        }
        /// The ID of the latest version associated with the definition.
        pub fn set_latest_version(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.latest_version = input;
            self
        }
        /// The ARN of the latest version associated with the definition.
        pub fn latest_version_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.latest_version_arn = Some(input.into());
            self
        }
        /// The ARN of the latest version associated with the definition.
        pub fn set_latest_version_arn(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.latest_version_arn = input;
            self
        }
        /// The name of the definition.
        pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
            self.name = Some(input.into());
            self
        }
        /// The name of the definition.
        pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.name = input;
            self
        }
        /// Adds a key-value pair to `tags`.
        ///
        /// To override the contents of this collection use [`set_tags`](Self::set_tags).
        ///
        /// Tag(s) attached to the resource arn.
        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
        }
        /// Tag(s) attached to the resource arn.
        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 [`GetConnectorDefinitionOutput`](crate::output::GetConnectorDefinitionOutput).
        pub fn build(self) -> crate::output::GetConnectorDefinitionOutput {
            crate::output::GetConnectorDefinitionOutput {
                arn: self.arn,
                creation_timestamp: self.creation_timestamp,
                id: self.id,
                last_updated_timestamp: self.last_updated_timestamp,
                latest_version: self.latest_version,
                latest_version_arn: self.latest_version_arn,
                name: self.name,
                tags: self.tags,
            }
        }
    }
}
impl GetConnectorDefinitionOutput {
    /// Creates a new builder-style object to manufacture [`GetConnectorDefinitionOutput`](crate::output::GetConnectorDefinitionOutput).
    pub fn builder() -> crate::output::get_connector_definition_output::Builder {
        crate::output::get_connector_definition_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetConnectivityInfoOutput {
    /// Connectivity info list.
    #[doc(hidden)]
    pub connectivity_info: std::option::Option<std::vec::Vec<crate::model::ConnectivityInfo>>,
    /// A message about the connectivity info request.
    #[doc(hidden)]
    pub message: std::option::Option<std::string::String>,
}
impl GetConnectivityInfoOutput {
    /// Connectivity info list.
    pub fn connectivity_info(&self) -> std::option::Option<&[crate::model::ConnectivityInfo]> {
        self.connectivity_info.as_deref()
    }
    /// A message about the connectivity info request.
    pub fn message(&self) -> std::option::Option<&str> {
        self.message.as_deref()
    }
}
impl std::fmt::Debug for GetConnectivityInfoOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetConnectivityInfoOutput");
        formatter.field("connectivity_info", &self.connectivity_info);
        formatter.field("message", &self.message);
        formatter.finish()
    }
}
/// See [`GetConnectivityInfoOutput`](crate::output::GetConnectivityInfoOutput).
pub mod get_connectivity_info_output {

    /// A builder for [`GetConnectivityInfoOutput`](crate::output::GetConnectivityInfoOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) connectivity_info:
            std::option::Option<std::vec::Vec<crate::model::ConnectivityInfo>>,
        pub(crate) message: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `connectivity_info`.
        ///
        /// To override the contents of this collection use [`set_connectivity_info`](Self::set_connectivity_info).
        ///
        /// Connectivity info list.
        pub fn connectivity_info(mut self, input: crate::model::ConnectivityInfo) -> Self {
            let mut v = self.connectivity_info.unwrap_or_default();
            v.push(input);
            self.connectivity_info = Some(v);
            self
        }
        /// Connectivity info list.
        pub fn set_connectivity_info(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ConnectivityInfo>>,
        ) -> Self {
            self.connectivity_info = input;
            self
        }
        /// A message about the connectivity info request.
        pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
            self.message = Some(input.into());
            self
        }
        /// A message about the connectivity info request.
        pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.message = input;
            self
        }
        /// Consumes the builder and constructs a [`GetConnectivityInfoOutput`](crate::output::GetConnectivityInfoOutput).
        pub fn build(self) -> crate::output::GetConnectivityInfoOutput {
            crate::output::GetConnectivityInfoOutput {
                connectivity_info: self.connectivity_info,
                message: self.message,
            }
        }
    }
}
impl GetConnectivityInfoOutput {
    /// Creates a new builder-style object to manufacture [`GetConnectivityInfoOutput`](crate::output::GetConnectivityInfoOutput).
    pub fn builder() -> crate::output::get_connectivity_info_output::Builder {
        crate::output::get_connectivity_info_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetBulkDeploymentStatusOutput {
    /// Relevant metrics on input records processed during bulk deployment.
    #[doc(hidden)]
    pub bulk_deployment_metrics: std::option::Option<crate::model::BulkDeploymentMetrics>,
    /// The status of the bulk deployment.
    #[doc(hidden)]
    pub bulk_deployment_status: std::option::Option<crate::model::BulkDeploymentStatus>,
    /// The time, in ISO format, when the deployment was created.
    #[doc(hidden)]
    pub created_at: std::option::Option<std::string::String>,
    /// Error details
    #[doc(hidden)]
    pub error_details: std::option::Option<std::vec::Vec<crate::model::ErrorDetail>>,
    /// Error message
    #[doc(hidden)]
    pub error_message: std::option::Option<std::string::String>,
    /// Tag(s) attached to the resource arn.
    #[doc(hidden)]
    pub tags:
        std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl GetBulkDeploymentStatusOutput {
    /// Relevant metrics on input records processed during bulk deployment.
    pub fn bulk_deployment_metrics(
        &self,
    ) -> std::option::Option<&crate::model::BulkDeploymentMetrics> {
        self.bulk_deployment_metrics.as_ref()
    }
    /// The status of the bulk deployment.
    pub fn bulk_deployment_status(
        &self,
    ) -> std::option::Option<&crate::model::BulkDeploymentStatus> {
        self.bulk_deployment_status.as_ref()
    }
    /// The time, in ISO format, when the deployment was created.
    pub fn created_at(&self) -> std::option::Option<&str> {
        self.created_at.as_deref()
    }
    /// Error details
    pub fn error_details(&self) -> std::option::Option<&[crate::model::ErrorDetail]> {
        self.error_details.as_deref()
    }
    /// Error message
    pub fn error_message(&self) -> std::option::Option<&str> {
        self.error_message.as_deref()
    }
    /// Tag(s) attached to the resource arn.
    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 GetBulkDeploymentStatusOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetBulkDeploymentStatusOutput");
        formatter.field("bulk_deployment_metrics", &self.bulk_deployment_metrics);
        formatter.field("bulk_deployment_status", &self.bulk_deployment_status);
        formatter.field("created_at", &self.created_at);
        formatter.field("error_details", &self.error_details);
        formatter.field("error_message", &self.error_message);
        formatter.field("tags", &self.tags);
        formatter.finish()
    }
}
/// See [`GetBulkDeploymentStatusOutput`](crate::output::GetBulkDeploymentStatusOutput).
pub mod get_bulk_deployment_status_output {

    /// A builder for [`GetBulkDeploymentStatusOutput`](crate::output::GetBulkDeploymentStatusOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) bulk_deployment_metrics:
            std::option::Option<crate::model::BulkDeploymentMetrics>,
        pub(crate) bulk_deployment_status: std::option::Option<crate::model::BulkDeploymentStatus>,
        pub(crate) created_at: std::option::Option<std::string::String>,
        pub(crate) error_details: std::option::Option<std::vec::Vec<crate::model::ErrorDetail>>,
        pub(crate) error_message: std::option::Option<std::string::String>,
        pub(crate) tags: std::option::Option<
            std::collections::HashMap<std::string::String, std::string::String>,
        >,
    }
    impl Builder {
        /// Relevant metrics on input records processed during bulk deployment.
        pub fn bulk_deployment_metrics(
            mut self,
            input: crate::model::BulkDeploymentMetrics,
        ) -> Self {
            self.bulk_deployment_metrics = Some(input);
            self
        }
        /// Relevant metrics on input records processed during bulk deployment.
        pub fn set_bulk_deployment_metrics(
            mut self,
            input: std::option::Option<crate::model::BulkDeploymentMetrics>,
        ) -> Self {
            self.bulk_deployment_metrics = input;
            self
        }
        /// The status of the bulk deployment.
        pub fn bulk_deployment_status(mut self, input: crate::model::BulkDeploymentStatus) -> Self {
            self.bulk_deployment_status = Some(input);
            self
        }
        /// The status of the bulk deployment.
        pub fn set_bulk_deployment_status(
            mut self,
            input: std::option::Option<crate::model::BulkDeploymentStatus>,
        ) -> Self {
            self.bulk_deployment_status = input;
            self
        }
        /// The time, in ISO format, when the deployment was created.
        pub fn created_at(mut self, input: impl Into<std::string::String>) -> Self {
            self.created_at = Some(input.into());
            self
        }
        /// The time, in ISO format, when the deployment was created.
        pub fn set_created_at(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.created_at = input;
            self
        }
        /// Appends an item to `error_details`.
        ///
        /// To override the contents of this collection use [`set_error_details`](Self::set_error_details).
        ///
        /// Error details
        pub fn error_details(mut self, input: crate::model::ErrorDetail) -> Self {
            let mut v = self.error_details.unwrap_or_default();
            v.push(input);
            self.error_details = Some(v);
            self
        }
        /// Error details
        pub fn set_error_details(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ErrorDetail>>,
        ) -> Self {
            self.error_details = input;
            self
        }
        /// Error message
        pub fn error_message(mut self, input: impl Into<std::string::String>) -> Self {
            self.error_message = Some(input.into());
            self
        }
        /// Error message
        pub fn set_error_message(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.error_message = input;
            self
        }
        /// Adds a key-value pair to `tags`.
        ///
        /// To override the contents of this collection use [`set_tags`](Self::set_tags).
        ///
        /// Tag(s) attached to the resource arn.
        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
        }
        /// Tag(s) attached to the resource arn.
        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 [`GetBulkDeploymentStatusOutput`](crate::output::GetBulkDeploymentStatusOutput).
        pub fn build(self) -> crate::output::GetBulkDeploymentStatusOutput {
            crate::output::GetBulkDeploymentStatusOutput {
                bulk_deployment_metrics: self.bulk_deployment_metrics,
                bulk_deployment_status: self.bulk_deployment_status,
                created_at: self.created_at,
                error_details: self.error_details,
                error_message: self.error_message,
                tags: self.tags,
            }
        }
    }
}
impl GetBulkDeploymentStatusOutput {
    /// Creates a new builder-style object to manufacture [`GetBulkDeploymentStatusOutput`](crate::output::GetBulkDeploymentStatusOutput).
    pub fn builder() -> crate::output::get_bulk_deployment_status_output::Builder {
        crate::output::get_bulk_deployment_status_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetAssociatedRoleOutput {
    /// The time when the role was associated with the group.
    #[doc(hidden)]
    pub associated_at: std::option::Option<std::string::String>,
    /// The ARN of the role that is associated with the group.
    #[doc(hidden)]
    pub role_arn: std::option::Option<std::string::String>,
}
impl GetAssociatedRoleOutput {
    /// The time when the role was associated with the group.
    pub fn associated_at(&self) -> std::option::Option<&str> {
        self.associated_at.as_deref()
    }
    /// The ARN of the role that is associated with the group.
    pub fn role_arn(&self) -> std::option::Option<&str> {
        self.role_arn.as_deref()
    }
}
impl std::fmt::Debug for GetAssociatedRoleOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetAssociatedRoleOutput");
        formatter.field("associated_at", &self.associated_at);
        formatter.field("role_arn", &self.role_arn);
        formatter.finish()
    }
}
/// See [`GetAssociatedRoleOutput`](crate::output::GetAssociatedRoleOutput).
pub mod get_associated_role_output {

    /// A builder for [`GetAssociatedRoleOutput`](crate::output::GetAssociatedRoleOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) associated_at: std::option::Option<std::string::String>,
        pub(crate) role_arn: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The time when the role was associated with the group.
        pub fn associated_at(mut self, input: impl Into<std::string::String>) -> Self {
            self.associated_at = Some(input.into());
            self
        }
        /// The time when the role was associated with the group.
        pub fn set_associated_at(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.associated_at = input;
            self
        }
        /// The ARN of the role that is associated with the group.
        pub fn role_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.role_arn = Some(input.into());
            self
        }
        /// The ARN of the role that is associated with the group.
        pub fn set_role_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.role_arn = input;
            self
        }
        /// Consumes the builder and constructs a [`GetAssociatedRoleOutput`](crate::output::GetAssociatedRoleOutput).
        pub fn build(self) -> crate::output::GetAssociatedRoleOutput {
            crate::output::GetAssociatedRoleOutput {
                associated_at: self.associated_at,
                role_arn: self.role_arn,
            }
        }
    }
}
impl GetAssociatedRoleOutput {
    /// Creates a new builder-style object to manufacture [`GetAssociatedRoleOutput`](crate::output::GetAssociatedRoleOutput).
    pub fn builder() -> crate::output::get_associated_role_output::Builder {
        crate::output::get_associated_role_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DisassociateServiceRoleFromAccountOutput {
    /// The time when the service role was disassociated from the account.
    #[doc(hidden)]
    pub disassociated_at: std::option::Option<std::string::String>,
}
impl DisassociateServiceRoleFromAccountOutput {
    /// The time when the service role was disassociated from the account.
    pub fn disassociated_at(&self) -> std::option::Option<&str> {
        self.disassociated_at.as_deref()
    }
}
impl std::fmt::Debug for DisassociateServiceRoleFromAccountOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DisassociateServiceRoleFromAccountOutput");
        formatter.field("disassociated_at", &self.disassociated_at);
        formatter.finish()
    }
}
/// See [`DisassociateServiceRoleFromAccountOutput`](crate::output::DisassociateServiceRoleFromAccountOutput).
pub mod disassociate_service_role_from_account_output {

    /// A builder for [`DisassociateServiceRoleFromAccountOutput`](crate::output::DisassociateServiceRoleFromAccountOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) disassociated_at: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The time when the service role was disassociated from the account.
        pub fn disassociated_at(mut self, input: impl Into<std::string::String>) -> Self {
            self.disassociated_at = Some(input.into());
            self
        }
        /// The time when the service role was disassociated from the account.
        pub fn set_disassociated_at(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.disassociated_at = input;
            self
        }
        /// Consumes the builder and constructs a [`DisassociateServiceRoleFromAccountOutput`](crate::output::DisassociateServiceRoleFromAccountOutput).
        pub fn build(self) -> crate::output::DisassociateServiceRoleFromAccountOutput {
            crate::output::DisassociateServiceRoleFromAccountOutput {
                disassociated_at: self.disassociated_at,
            }
        }
    }
}
impl DisassociateServiceRoleFromAccountOutput {
    /// Creates a new builder-style object to manufacture [`DisassociateServiceRoleFromAccountOutput`](crate::output::DisassociateServiceRoleFromAccountOutput).
    pub fn builder() -> crate::output::disassociate_service_role_from_account_output::Builder {
        crate::output::disassociate_service_role_from_account_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DisassociateRoleFromGroupOutput {
    /// The time, in milliseconds since the epoch, when the role was disassociated from the group.
    #[doc(hidden)]
    pub disassociated_at: std::option::Option<std::string::String>,
}
impl DisassociateRoleFromGroupOutput {
    /// The time, in milliseconds since the epoch, when the role was disassociated from the group.
    pub fn disassociated_at(&self) -> std::option::Option<&str> {
        self.disassociated_at.as_deref()
    }
}
impl std::fmt::Debug for DisassociateRoleFromGroupOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DisassociateRoleFromGroupOutput");
        formatter.field("disassociated_at", &self.disassociated_at);
        formatter.finish()
    }
}
/// See [`DisassociateRoleFromGroupOutput`](crate::output::DisassociateRoleFromGroupOutput).
pub mod disassociate_role_from_group_output {

    /// A builder for [`DisassociateRoleFromGroupOutput`](crate::output::DisassociateRoleFromGroupOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) disassociated_at: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The time, in milliseconds since the epoch, when the role was disassociated from the group.
        pub fn disassociated_at(mut self, input: impl Into<std::string::String>) -> Self {
            self.disassociated_at = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the role was disassociated from the group.
        pub fn set_disassociated_at(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.disassociated_at = input;
            self
        }
        /// Consumes the builder and constructs a [`DisassociateRoleFromGroupOutput`](crate::output::DisassociateRoleFromGroupOutput).
        pub fn build(self) -> crate::output::DisassociateRoleFromGroupOutput {
            crate::output::DisassociateRoleFromGroupOutput {
                disassociated_at: self.disassociated_at,
            }
        }
    }
}
impl DisassociateRoleFromGroupOutput {
    /// Creates a new builder-style object to manufacture [`DisassociateRoleFromGroupOutput`](crate::output::DisassociateRoleFromGroupOutput).
    pub fn builder() -> crate::output::disassociate_role_from_group_output::Builder {
        crate::output::disassociate_role_from_group_output::Builder::default()
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateSubscriptionDefinitionVersionOutput {
    /// The ARN of the version.
    #[doc(hidden)]
    pub arn: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the version was created.
    #[doc(hidden)]
    pub creation_timestamp: std::option::Option<std::string::String>,
    /// The ID of the parent definition that the version is associated with.
    #[doc(hidden)]
    pub id: std::option::Option<std::string::String>,
    /// The ID of the version.
    #[doc(hidden)]
    pub version: std::option::Option<std::string::String>,
}
impl CreateSubscriptionDefinitionVersionOutput {
    /// The ARN of the version.
    pub fn arn(&self) -> std::option::Option<&str> {
        self.arn.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the version was created.
    pub fn creation_timestamp(&self) -> std::option::Option<&str> {
        self.creation_timestamp.as_deref()
    }
    /// The ID of the parent definition that the version is associated with.
    pub fn id(&self) -> std::option::Option<&str> {
        self.id.as_deref()
    }
    /// The ID of the version.
    pub fn version(&self) -> std::option::Option<&str> {
        self.version.as_deref()
    }
}
impl std::fmt::Debug for CreateSubscriptionDefinitionVersionOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateSubscriptionDefinitionVersionOutput");
        formatter.field("arn", &self.arn);
        formatter.field("creation_timestamp", &self.creation_timestamp);
        formatter.field("id", &self.id);
        formatter.field("version", &self.version);
        formatter.finish()
    }
}
/// See [`CreateSubscriptionDefinitionVersionOutput`](crate::output::CreateSubscriptionDefinitionVersionOutput).
pub mod create_subscription_definition_version_output {

    /// A builder for [`CreateSubscriptionDefinitionVersionOutput`](crate::output::CreateSubscriptionDefinitionVersionOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) arn: std::option::Option<std::string::String>,
        pub(crate) creation_timestamp: std::option::Option<std::string::String>,
        pub(crate) id: std::option::Option<std::string::String>,
        pub(crate) version: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The ARN of the version.
        pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.arn = Some(input.into());
            self
        }
        /// The ARN of the version.
        pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.arn = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the version was created.
        pub fn creation_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.creation_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the version was created.
        pub fn set_creation_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.creation_timestamp = input;
            self
        }
        /// The ID of the parent definition that the version is associated with.
        pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
            self.id = Some(input.into());
            self
        }
        /// The ID of the parent definition that the version is associated with.
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.id = input;
            self
        }
        /// The ID of the version.
        pub fn version(mut self, input: impl Into<std::string::String>) -> Self {
            self.version = Some(input.into());
            self
        }
        /// The ID of the version.
        pub fn set_version(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.version = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateSubscriptionDefinitionVersionOutput`](crate::output::CreateSubscriptionDefinitionVersionOutput).
        pub fn build(self) -> crate::output::CreateSubscriptionDefinitionVersionOutput {
            crate::output::CreateSubscriptionDefinitionVersionOutput {
                arn: self.arn,
                creation_timestamp: self.creation_timestamp,
                id: self.id,
                version: self.version,
            }
        }
    }
}
impl CreateSubscriptionDefinitionVersionOutput {
    /// Creates a new builder-style object to manufacture [`CreateSubscriptionDefinitionVersionOutput`](crate::output::CreateSubscriptionDefinitionVersionOutput).
    pub fn builder() -> crate::output::create_subscription_definition_version_output::Builder {
        crate::output::create_subscription_definition_version_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateSubscriptionDefinitionOutput {
    /// The ARN of the definition.
    #[doc(hidden)]
    pub arn: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the definition was created.
    #[doc(hidden)]
    pub creation_timestamp: std::option::Option<std::string::String>,
    /// The ID of the definition.
    #[doc(hidden)]
    pub id: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the definition was last updated.
    #[doc(hidden)]
    pub last_updated_timestamp: std::option::Option<std::string::String>,
    /// The ID of the latest version associated with the definition.
    #[doc(hidden)]
    pub latest_version: std::option::Option<std::string::String>,
    /// The ARN of the latest version associated with the definition.
    #[doc(hidden)]
    pub latest_version_arn: std::option::Option<std::string::String>,
    /// The name of the definition.
    #[doc(hidden)]
    pub name: std::option::Option<std::string::String>,
}
impl CreateSubscriptionDefinitionOutput {
    /// The ARN of the definition.
    pub fn arn(&self) -> std::option::Option<&str> {
        self.arn.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the definition was created.
    pub fn creation_timestamp(&self) -> std::option::Option<&str> {
        self.creation_timestamp.as_deref()
    }
    /// The ID of the definition.
    pub fn id(&self) -> std::option::Option<&str> {
        self.id.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the definition was last updated.
    pub fn last_updated_timestamp(&self) -> std::option::Option<&str> {
        self.last_updated_timestamp.as_deref()
    }
    /// The ID of the latest version associated with the definition.
    pub fn latest_version(&self) -> std::option::Option<&str> {
        self.latest_version.as_deref()
    }
    /// The ARN of the latest version associated with the definition.
    pub fn latest_version_arn(&self) -> std::option::Option<&str> {
        self.latest_version_arn.as_deref()
    }
    /// The name of the definition.
    pub fn name(&self) -> std::option::Option<&str> {
        self.name.as_deref()
    }
}
impl std::fmt::Debug for CreateSubscriptionDefinitionOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateSubscriptionDefinitionOutput");
        formatter.field("arn", &self.arn);
        formatter.field("creation_timestamp", &self.creation_timestamp);
        formatter.field("id", &self.id);
        formatter.field("last_updated_timestamp", &self.last_updated_timestamp);
        formatter.field("latest_version", &self.latest_version);
        formatter.field("latest_version_arn", &self.latest_version_arn);
        formatter.field("name", &self.name);
        formatter.finish()
    }
}
/// See [`CreateSubscriptionDefinitionOutput`](crate::output::CreateSubscriptionDefinitionOutput).
pub mod create_subscription_definition_output {

    /// A builder for [`CreateSubscriptionDefinitionOutput`](crate::output::CreateSubscriptionDefinitionOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) arn: std::option::Option<std::string::String>,
        pub(crate) creation_timestamp: std::option::Option<std::string::String>,
        pub(crate) id: std::option::Option<std::string::String>,
        pub(crate) last_updated_timestamp: std::option::Option<std::string::String>,
        pub(crate) latest_version: std::option::Option<std::string::String>,
        pub(crate) latest_version_arn: std::option::Option<std::string::String>,
        pub(crate) name: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The ARN of the definition.
        pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.arn = Some(input.into());
            self
        }
        /// The ARN of the definition.
        pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.arn = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was created.
        pub fn creation_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.creation_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was created.
        pub fn set_creation_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.creation_timestamp = input;
            self
        }
        /// The ID of the definition.
        pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
            self.id = Some(input.into());
            self
        }
        /// The ID of the definition.
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.id = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was last updated.
        pub fn last_updated_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.last_updated_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was last updated.
        pub fn set_last_updated_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.last_updated_timestamp = input;
            self
        }
        /// The ID of the latest version associated with the definition.
        pub fn latest_version(mut self, input: impl Into<std::string::String>) -> Self {
            self.latest_version = Some(input.into());
            self
        }
        /// The ID of the latest version associated with the definition.
        pub fn set_latest_version(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.latest_version = input;
            self
        }
        /// The ARN of the latest version associated with the definition.
        pub fn latest_version_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.latest_version_arn = Some(input.into());
            self
        }
        /// The ARN of the latest version associated with the definition.
        pub fn set_latest_version_arn(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.latest_version_arn = input;
            self
        }
        /// The name of the definition.
        pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
            self.name = Some(input.into());
            self
        }
        /// The name of the definition.
        pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.name = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateSubscriptionDefinitionOutput`](crate::output::CreateSubscriptionDefinitionOutput).
        pub fn build(self) -> crate::output::CreateSubscriptionDefinitionOutput {
            crate::output::CreateSubscriptionDefinitionOutput {
                arn: self.arn,
                creation_timestamp: self.creation_timestamp,
                id: self.id,
                last_updated_timestamp: self.last_updated_timestamp,
                latest_version: self.latest_version,
                latest_version_arn: self.latest_version_arn,
                name: self.name,
            }
        }
    }
}
impl CreateSubscriptionDefinitionOutput {
    /// Creates a new builder-style object to manufacture [`CreateSubscriptionDefinitionOutput`](crate::output::CreateSubscriptionDefinitionOutput).
    pub fn builder() -> crate::output::create_subscription_definition_output::Builder {
        crate::output::create_subscription_definition_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateSoftwareUpdateJobOutput {
    /// The IoT Job ARN corresponding to this update.
    #[doc(hidden)]
    pub iot_job_arn: std::option::Option<std::string::String>,
    /// The IoT Job Id corresponding to this update.
    #[doc(hidden)]
    pub iot_job_id: std::option::Option<std::string::String>,
    /// The software version installed on the device or devices after the update.
    #[doc(hidden)]
    pub platform_software_version: std::option::Option<std::string::String>,
}
impl CreateSoftwareUpdateJobOutput {
    /// The IoT Job ARN corresponding to this update.
    pub fn iot_job_arn(&self) -> std::option::Option<&str> {
        self.iot_job_arn.as_deref()
    }
    /// The IoT Job Id corresponding to this update.
    pub fn iot_job_id(&self) -> std::option::Option<&str> {
        self.iot_job_id.as_deref()
    }
    /// The software version installed on the device or devices after the update.
    pub fn platform_software_version(&self) -> std::option::Option<&str> {
        self.platform_software_version.as_deref()
    }
}
impl std::fmt::Debug for CreateSoftwareUpdateJobOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateSoftwareUpdateJobOutput");
        formatter.field("iot_job_arn", &self.iot_job_arn);
        formatter.field("iot_job_id", &self.iot_job_id);
        formatter.field("platform_software_version", &self.platform_software_version);
        formatter.finish()
    }
}
/// See [`CreateSoftwareUpdateJobOutput`](crate::output::CreateSoftwareUpdateJobOutput).
pub mod create_software_update_job_output {

    /// A builder for [`CreateSoftwareUpdateJobOutput`](crate::output::CreateSoftwareUpdateJobOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) iot_job_arn: std::option::Option<std::string::String>,
        pub(crate) iot_job_id: std::option::Option<std::string::String>,
        pub(crate) platform_software_version: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The IoT Job ARN corresponding to this update.
        pub fn iot_job_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.iot_job_arn = Some(input.into());
            self
        }
        /// The IoT Job ARN corresponding to this update.
        pub fn set_iot_job_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.iot_job_arn = input;
            self
        }
        /// The IoT Job Id corresponding to this update.
        pub fn iot_job_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.iot_job_id = Some(input.into());
            self
        }
        /// The IoT Job Id corresponding to this update.
        pub fn set_iot_job_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.iot_job_id = input;
            self
        }
        /// The software version installed on the device or devices after the update.
        pub fn platform_software_version(mut self, input: impl Into<std::string::String>) -> Self {
            self.platform_software_version = Some(input.into());
            self
        }
        /// The software version installed on the device or devices after the update.
        pub fn set_platform_software_version(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.platform_software_version = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateSoftwareUpdateJobOutput`](crate::output::CreateSoftwareUpdateJobOutput).
        pub fn build(self) -> crate::output::CreateSoftwareUpdateJobOutput {
            crate::output::CreateSoftwareUpdateJobOutput {
                iot_job_arn: self.iot_job_arn,
                iot_job_id: self.iot_job_id,
                platform_software_version: self.platform_software_version,
            }
        }
    }
}
impl CreateSoftwareUpdateJobOutput {
    /// Creates a new builder-style object to manufacture [`CreateSoftwareUpdateJobOutput`](crate::output::CreateSoftwareUpdateJobOutput).
    pub fn builder() -> crate::output::create_software_update_job_output::Builder {
        crate::output::create_software_update_job_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateResourceDefinitionVersionOutput {
    /// The ARN of the version.
    #[doc(hidden)]
    pub arn: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the version was created.
    #[doc(hidden)]
    pub creation_timestamp: std::option::Option<std::string::String>,
    /// The ID of the parent definition that the version is associated with.
    #[doc(hidden)]
    pub id: std::option::Option<std::string::String>,
    /// The ID of the version.
    #[doc(hidden)]
    pub version: std::option::Option<std::string::String>,
}
impl CreateResourceDefinitionVersionOutput {
    /// The ARN of the version.
    pub fn arn(&self) -> std::option::Option<&str> {
        self.arn.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the version was created.
    pub fn creation_timestamp(&self) -> std::option::Option<&str> {
        self.creation_timestamp.as_deref()
    }
    /// The ID of the parent definition that the version is associated with.
    pub fn id(&self) -> std::option::Option<&str> {
        self.id.as_deref()
    }
    /// The ID of the version.
    pub fn version(&self) -> std::option::Option<&str> {
        self.version.as_deref()
    }
}
impl std::fmt::Debug for CreateResourceDefinitionVersionOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateResourceDefinitionVersionOutput");
        formatter.field("arn", &self.arn);
        formatter.field("creation_timestamp", &self.creation_timestamp);
        formatter.field("id", &self.id);
        formatter.field("version", &self.version);
        formatter.finish()
    }
}
/// See [`CreateResourceDefinitionVersionOutput`](crate::output::CreateResourceDefinitionVersionOutput).
pub mod create_resource_definition_version_output {

    /// A builder for [`CreateResourceDefinitionVersionOutput`](crate::output::CreateResourceDefinitionVersionOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) arn: std::option::Option<std::string::String>,
        pub(crate) creation_timestamp: std::option::Option<std::string::String>,
        pub(crate) id: std::option::Option<std::string::String>,
        pub(crate) version: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The ARN of the version.
        pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.arn = Some(input.into());
            self
        }
        /// The ARN of the version.
        pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.arn = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the version was created.
        pub fn creation_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.creation_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the version was created.
        pub fn set_creation_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.creation_timestamp = input;
            self
        }
        /// The ID of the parent definition that the version is associated with.
        pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
            self.id = Some(input.into());
            self
        }
        /// The ID of the parent definition that the version is associated with.
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.id = input;
            self
        }
        /// The ID of the version.
        pub fn version(mut self, input: impl Into<std::string::String>) -> Self {
            self.version = Some(input.into());
            self
        }
        /// The ID of the version.
        pub fn set_version(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.version = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateResourceDefinitionVersionOutput`](crate::output::CreateResourceDefinitionVersionOutput).
        pub fn build(self) -> crate::output::CreateResourceDefinitionVersionOutput {
            crate::output::CreateResourceDefinitionVersionOutput {
                arn: self.arn,
                creation_timestamp: self.creation_timestamp,
                id: self.id,
                version: self.version,
            }
        }
    }
}
impl CreateResourceDefinitionVersionOutput {
    /// Creates a new builder-style object to manufacture [`CreateResourceDefinitionVersionOutput`](crate::output::CreateResourceDefinitionVersionOutput).
    pub fn builder() -> crate::output::create_resource_definition_version_output::Builder {
        crate::output::create_resource_definition_version_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateResourceDefinitionOutput {
    /// The ARN of the definition.
    #[doc(hidden)]
    pub arn: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the definition was created.
    #[doc(hidden)]
    pub creation_timestamp: std::option::Option<std::string::String>,
    /// The ID of the definition.
    #[doc(hidden)]
    pub id: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the definition was last updated.
    #[doc(hidden)]
    pub last_updated_timestamp: std::option::Option<std::string::String>,
    /// The ID of the latest version associated with the definition.
    #[doc(hidden)]
    pub latest_version: std::option::Option<std::string::String>,
    /// The ARN of the latest version associated with the definition.
    #[doc(hidden)]
    pub latest_version_arn: std::option::Option<std::string::String>,
    /// The name of the definition.
    #[doc(hidden)]
    pub name: std::option::Option<std::string::String>,
}
impl CreateResourceDefinitionOutput {
    /// The ARN of the definition.
    pub fn arn(&self) -> std::option::Option<&str> {
        self.arn.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the definition was created.
    pub fn creation_timestamp(&self) -> std::option::Option<&str> {
        self.creation_timestamp.as_deref()
    }
    /// The ID of the definition.
    pub fn id(&self) -> std::option::Option<&str> {
        self.id.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the definition was last updated.
    pub fn last_updated_timestamp(&self) -> std::option::Option<&str> {
        self.last_updated_timestamp.as_deref()
    }
    /// The ID of the latest version associated with the definition.
    pub fn latest_version(&self) -> std::option::Option<&str> {
        self.latest_version.as_deref()
    }
    /// The ARN of the latest version associated with the definition.
    pub fn latest_version_arn(&self) -> std::option::Option<&str> {
        self.latest_version_arn.as_deref()
    }
    /// The name of the definition.
    pub fn name(&self) -> std::option::Option<&str> {
        self.name.as_deref()
    }
}
impl std::fmt::Debug for CreateResourceDefinitionOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateResourceDefinitionOutput");
        formatter.field("arn", &self.arn);
        formatter.field("creation_timestamp", &self.creation_timestamp);
        formatter.field("id", &self.id);
        formatter.field("last_updated_timestamp", &self.last_updated_timestamp);
        formatter.field("latest_version", &self.latest_version);
        formatter.field("latest_version_arn", &self.latest_version_arn);
        formatter.field("name", &self.name);
        formatter.finish()
    }
}
/// See [`CreateResourceDefinitionOutput`](crate::output::CreateResourceDefinitionOutput).
pub mod create_resource_definition_output {

    /// A builder for [`CreateResourceDefinitionOutput`](crate::output::CreateResourceDefinitionOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) arn: std::option::Option<std::string::String>,
        pub(crate) creation_timestamp: std::option::Option<std::string::String>,
        pub(crate) id: std::option::Option<std::string::String>,
        pub(crate) last_updated_timestamp: std::option::Option<std::string::String>,
        pub(crate) latest_version: std::option::Option<std::string::String>,
        pub(crate) latest_version_arn: std::option::Option<std::string::String>,
        pub(crate) name: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The ARN of the definition.
        pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.arn = Some(input.into());
            self
        }
        /// The ARN of the definition.
        pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.arn = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was created.
        pub fn creation_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.creation_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was created.
        pub fn set_creation_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.creation_timestamp = input;
            self
        }
        /// The ID of the definition.
        pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
            self.id = Some(input.into());
            self
        }
        /// The ID of the definition.
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.id = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was last updated.
        pub fn last_updated_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.last_updated_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was last updated.
        pub fn set_last_updated_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.last_updated_timestamp = input;
            self
        }
        /// The ID of the latest version associated with the definition.
        pub fn latest_version(mut self, input: impl Into<std::string::String>) -> Self {
            self.latest_version = Some(input.into());
            self
        }
        /// The ID of the latest version associated with the definition.
        pub fn set_latest_version(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.latest_version = input;
            self
        }
        /// The ARN of the latest version associated with the definition.
        pub fn latest_version_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.latest_version_arn = Some(input.into());
            self
        }
        /// The ARN of the latest version associated with the definition.
        pub fn set_latest_version_arn(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.latest_version_arn = input;
            self
        }
        /// The name of the definition.
        pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
            self.name = Some(input.into());
            self
        }
        /// The name of the definition.
        pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.name = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateResourceDefinitionOutput`](crate::output::CreateResourceDefinitionOutput).
        pub fn build(self) -> crate::output::CreateResourceDefinitionOutput {
            crate::output::CreateResourceDefinitionOutput {
                arn: self.arn,
                creation_timestamp: self.creation_timestamp,
                id: self.id,
                last_updated_timestamp: self.last_updated_timestamp,
                latest_version: self.latest_version,
                latest_version_arn: self.latest_version_arn,
                name: self.name,
            }
        }
    }
}
impl CreateResourceDefinitionOutput {
    /// Creates a new builder-style object to manufacture [`CreateResourceDefinitionOutput`](crate::output::CreateResourceDefinitionOutput).
    pub fn builder() -> crate::output::create_resource_definition_output::Builder {
        crate::output::create_resource_definition_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateLoggerDefinitionVersionOutput {
    /// The ARN of the version.
    #[doc(hidden)]
    pub arn: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the version was created.
    #[doc(hidden)]
    pub creation_timestamp: std::option::Option<std::string::String>,
    /// The ID of the parent definition that the version is associated with.
    #[doc(hidden)]
    pub id: std::option::Option<std::string::String>,
    /// The ID of the version.
    #[doc(hidden)]
    pub version: std::option::Option<std::string::String>,
}
impl CreateLoggerDefinitionVersionOutput {
    /// The ARN of the version.
    pub fn arn(&self) -> std::option::Option<&str> {
        self.arn.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the version was created.
    pub fn creation_timestamp(&self) -> std::option::Option<&str> {
        self.creation_timestamp.as_deref()
    }
    /// The ID of the parent definition that the version is associated with.
    pub fn id(&self) -> std::option::Option<&str> {
        self.id.as_deref()
    }
    /// The ID of the version.
    pub fn version(&self) -> std::option::Option<&str> {
        self.version.as_deref()
    }
}
impl std::fmt::Debug for CreateLoggerDefinitionVersionOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateLoggerDefinitionVersionOutput");
        formatter.field("arn", &self.arn);
        formatter.field("creation_timestamp", &self.creation_timestamp);
        formatter.field("id", &self.id);
        formatter.field("version", &self.version);
        formatter.finish()
    }
}
/// See [`CreateLoggerDefinitionVersionOutput`](crate::output::CreateLoggerDefinitionVersionOutput).
pub mod create_logger_definition_version_output {

    /// A builder for [`CreateLoggerDefinitionVersionOutput`](crate::output::CreateLoggerDefinitionVersionOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) arn: std::option::Option<std::string::String>,
        pub(crate) creation_timestamp: std::option::Option<std::string::String>,
        pub(crate) id: std::option::Option<std::string::String>,
        pub(crate) version: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The ARN of the version.
        pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.arn = Some(input.into());
            self
        }
        /// The ARN of the version.
        pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.arn = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the version was created.
        pub fn creation_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.creation_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the version was created.
        pub fn set_creation_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.creation_timestamp = input;
            self
        }
        /// The ID of the parent definition that the version is associated with.
        pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
            self.id = Some(input.into());
            self
        }
        /// The ID of the parent definition that the version is associated with.
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.id = input;
            self
        }
        /// The ID of the version.
        pub fn version(mut self, input: impl Into<std::string::String>) -> Self {
            self.version = Some(input.into());
            self
        }
        /// The ID of the version.
        pub fn set_version(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.version = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateLoggerDefinitionVersionOutput`](crate::output::CreateLoggerDefinitionVersionOutput).
        pub fn build(self) -> crate::output::CreateLoggerDefinitionVersionOutput {
            crate::output::CreateLoggerDefinitionVersionOutput {
                arn: self.arn,
                creation_timestamp: self.creation_timestamp,
                id: self.id,
                version: self.version,
            }
        }
    }
}
impl CreateLoggerDefinitionVersionOutput {
    /// Creates a new builder-style object to manufacture [`CreateLoggerDefinitionVersionOutput`](crate::output::CreateLoggerDefinitionVersionOutput).
    pub fn builder() -> crate::output::create_logger_definition_version_output::Builder {
        crate::output::create_logger_definition_version_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateLoggerDefinitionOutput {
    /// The ARN of the definition.
    #[doc(hidden)]
    pub arn: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the definition was created.
    #[doc(hidden)]
    pub creation_timestamp: std::option::Option<std::string::String>,
    /// The ID of the definition.
    #[doc(hidden)]
    pub id: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the definition was last updated.
    #[doc(hidden)]
    pub last_updated_timestamp: std::option::Option<std::string::String>,
    /// The ID of the latest version associated with the definition.
    #[doc(hidden)]
    pub latest_version: std::option::Option<std::string::String>,
    /// The ARN of the latest version associated with the definition.
    #[doc(hidden)]
    pub latest_version_arn: std::option::Option<std::string::String>,
    /// The name of the definition.
    #[doc(hidden)]
    pub name: std::option::Option<std::string::String>,
}
impl CreateLoggerDefinitionOutput {
    /// The ARN of the definition.
    pub fn arn(&self) -> std::option::Option<&str> {
        self.arn.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the definition was created.
    pub fn creation_timestamp(&self) -> std::option::Option<&str> {
        self.creation_timestamp.as_deref()
    }
    /// The ID of the definition.
    pub fn id(&self) -> std::option::Option<&str> {
        self.id.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the definition was last updated.
    pub fn last_updated_timestamp(&self) -> std::option::Option<&str> {
        self.last_updated_timestamp.as_deref()
    }
    /// The ID of the latest version associated with the definition.
    pub fn latest_version(&self) -> std::option::Option<&str> {
        self.latest_version.as_deref()
    }
    /// The ARN of the latest version associated with the definition.
    pub fn latest_version_arn(&self) -> std::option::Option<&str> {
        self.latest_version_arn.as_deref()
    }
    /// The name of the definition.
    pub fn name(&self) -> std::option::Option<&str> {
        self.name.as_deref()
    }
}
impl std::fmt::Debug for CreateLoggerDefinitionOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateLoggerDefinitionOutput");
        formatter.field("arn", &self.arn);
        formatter.field("creation_timestamp", &self.creation_timestamp);
        formatter.field("id", &self.id);
        formatter.field("last_updated_timestamp", &self.last_updated_timestamp);
        formatter.field("latest_version", &self.latest_version);
        formatter.field("latest_version_arn", &self.latest_version_arn);
        formatter.field("name", &self.name);
        formatter.finish()
    }
}
/// See [`CreateLoggerDefinitionOutput`](crate::output::CreateLoggerDefinitionOutput).
pub mod create_logger_definition_output {

    /// A builder for [`CreateLoggerDefinitionOutput`](crate::output::CreateLoggerDefinitionOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) arn: std::option::Option<std::string::String>,
        pub(crate) creation_timestamp: std::option::Option<std::string::String>,
        pub(crate) id: std::option::Option<std::string::String>,
        pub(crate) last_updated_timestamp: std::option::Option<std::string::String>,
        pub(crate) latest_version: std::option::Option<std::string::String>,
        pub(crate) latest_version_arn: std::option::Option<std::string::String>,
        pub(crate) name: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The ARN of the definition.
        pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.arn = Some(input.into());
            self
        }
        /// The ARN of the definition.
        pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.arn = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was created.
        pub fn creation_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.creation_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was created.
        pub fn set_creation_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.creation_timestamp = input;
            self
        }
        /// The ID of the definition.
        pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
            self.id = Some(input.into());
            self
        }
        /// The ID of the definition.
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.id = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was last updated.
        pub fn last_updated_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.last_updated_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was last updated.
        pub fn set_last_updated_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.last_updated_timestamp = input;
            self
        }
        /// The ID of the latest version associated with the definition.
        pub fn latest_version(mut self, input: impl Into<std::string::String>) -> Self {
            self.latest_version = Some(input.into());
            self
        }
        /// The ID of the latest version associated with the definition.
        pub fn set_latest_version(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.latest_version = input;
            self
        }
        /// The ARN of the latest version associated with the definition.
        pub fn latest_version_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.latest_version_arn = Some(input.into());
            self
        }
        /// The ARN of the latest version associated with the definition.
        pub fn set_latest_version_arn(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.latest_version_arn = input;
            self
        }
        /// The name of the definition.
        pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
            self.name = Some(input.into());
            self
        }
        /// The name of the definition.
        pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.name = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateLoggerDefinitionOutput`](crate::output::CreateLoggerDefinitionOutput).
        pub fn build(self) -> crate::output::CreateLoggerDefinitionOutput {
            crate::output::CreateLoggerDefinitionOutput {
                arn: self.arn,
                creation_timestamp: self.creation_timestamp,
                id: self.id,
                last_updated_timestamp: self.last_updated_timestamp,
                latest_version: self.latest_version,
                latest_version_arn: self.latest_version_arn,
                name: self.name,
            }
        }
    }
}
impl CreateLoggerDefinitionOutput {
    /// Creates a new builder-style object to manufacture [`CreateLoggerDefinitionOutput`](crate::output::CreateLoggerDefinitionOutput).
    pub fn builder() -> crate::output::create_logger_definition_output::Builder {
        crate::output::create_logger_definition_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateGroupVersionOutput {
    /// The ARN of the version.
    #[doc(hidden)]
    pub arn: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the version was created.
    #[doc(hidden)]
    pub creation_timestamp: std::option::Option<std::string::String>,
    /// The ID of the parent definition that the version is associated with.
    #[doc(hidden)]
    pub id: std::option::Option<std::string::String>,
    /// The ID of the version.
    #[doc(hidden)]
    pub version: std::option::Option<std::string::String>,
}
impl CreateGroupVersionOutput {
    /// The ARN of the version.
    pub fn arn(&self) -> std::option::Option<&str> {
        self.arn.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the version was created.
    pub fn creation_timestamp(&self) -> std::option::Option<&str> {
        self.creation_timestamp.as_deref()
    }
    /// The ID of the parent definition that the version is associated with.
    pub fn id(&self) -> std::option::Option<&str> {
        self.id.as_deref()
    }
    /// The ID of the version.
    pub fn version(&self) -> std::option::Option<&str> {
        self.version.as_deref()
    }
}
impl std::fmt::Debug for CreateGroupVersionOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateGroupVersionOutput");
        formatter.field("arn", &self.arn);
        formatter.field("creation_timestamp", &self.creation_timestamp);
        formatter.field("id", &self.id);
        formatter.field("version", &self.version);
        formatter.finish()
    }
}
/// See [`CreateGroupVersionOutput`](crate::output::CreateGroupVersionOutput).
pub mod create_group_version_output {

    /// A builder for [`CreateGroupVersionOutput`](crate::output::CreateGroupVersionOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) arn: std::option::Option<std::string::String>,
        pub(crate) creation_timestamp: std::option::Option<std::string::String>,
        pub(crate) id: std::option::Option<std::string::String>,
        pub(crate) version: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The ARN of the version.
        pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.arn = Some(input.into());
            self
        }
        /// The ARN of the version.
        pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.arn = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the version was created.
        pub fn creation_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.creation_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the version was created.
        pub fn set_creation_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.creation_timestamp = input;
            self
        }
        /// The ID of the parent definition that the version is associated with.
        pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
            self.id = Some(input.into());
            self
        }
        /// The ID of the parent definition that the version is associated with.
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.id = input;
            self
        }
        /// The ID of the version.
        pub fn version(mut self, input: impl Into<std::string::String>) -> Self {
            self.version = Some(input.into());
            self
        }
        /// The ID of the version.
        pub fn set_version(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.version = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateGroupVersionOutput`](crate::output::CreateGroupVersionOutput).
        pub fn build(self) -> crate::output::CreateGroupVersionOutput {
            crate::output::CreateGroupVersionOutput {
                arn: self.arn,
                creation_timestamp: self.creation_timestamp,
                id: self.id,
                version: self.version,
            }
        }
    }
}
impl CreateGroupVersionOutput {
    /// Creates a new builder-style object to manufacture [`CreateGroupVersionOutput`](crate::output::CreateGroupVersionOutput).
    pub fn builder() -> crate::output::create_group_version_output::Builder {
        crate::output::create_group_version_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateGroupCertificateAuthorityOutput {
    /// The ARN of the group certificate authority.
    #[doc(hidden)]
    pub group_certificate_authority_arn: std::option::Option<std::string::String>,
}
impl CreateGroupCertificateAuthorityOutput {
    /// The ARN of the group certificate authority.
    pub fn group_certificate_authority_arn(&self) -> std::option::Option<&str> {
        self.group_certificate_authority_arn.as_deref()
    }
}
impl std::fmt::Debug for CreateGroupCertificateAuthorityOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateGroupCertificateAuthorityOutput");
        formatter.field(
            "group_certificate_authority_arn",
            &self.group_certificate_authority_arn,
        );
        formatter.finish()
    }
}
/// See [`CreateGroupCertificateAuthorityOutput`](crate::output::CreateGroupCertificateAuthorityOutput).
pub mod create_group_certificate_authority_output {

    /// A builder for [`CreateGroupCertificateAuthorityOutput`](crate::output::CreateGroupCertificateAuthorityOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) group_certificate_authority_arn: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The ARN of the group certificate authority.
        pub fn group_certificate_authority_arn(
            mut self,
            input: impl Into<std::string::String>,
        ) -> Self {
            self.group_certificate_authority_arn = Some(input.into());
            self
        }
        /// The ARN of the group certificate authority.
        pub fn set_group_certificate_authority_arn(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.group_certificate_authority_arn = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateGroupCertificateAuthorityOutput`](crate::output::CreateGroupCertificateAuthorityOutput).
        pub fn build(self) -> crate::output::CreateGroupCertificateAuthorityOutput {
            crate::output::CreateGroupCertificateAuthorityOutput {
                group_certificate_authority_arn: self.group_certificate_authority_arn,
            }
        }
    }
}
impl CreateGroupCertificateAuthorityOutput {
    /// Creates a new builder-style object to manufacture [`CreateGroupCertificateAuthorityOutput`](crate::output::CreateGroupCertificateAuthorityOutput).
    pub fn builder() -> crate::output::create_group_certificate_authority_output::Builder {
        crate::output::create_group_certificate_authority_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateGroupOutput {
    /// The ARN of the definition.
    #[doc(hidden)]
    pub arn: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the definition was created.
    #[doc(hidden)]
    pub creation_timestamp: std::option::Option<std::string::String>,
    /// The ID of the definition.
    #[doc(hidden)]
    pub id: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the definition was last updated.
    #[doc(hidden)]
    pub last_updated_timestamp: std::option::Option<std::string::String>,
    /// The ID of the latest version associated with the definition.
    #[doc(hidden)]
    pub latest_version: std::option::Option<std::string::String>,
    /// The ARN of the latest version associated with the definition.
    #[doc(hidden)]
    pub latest_version_arn: std::option::Option<std::string::String>,
    /// The name of the definition.
    #[doc(hidden)]
    pub name: std::option::Option<std::string::String>,
}
impl CreateGroupOutput {
    /// The ARN of the definition.
    pub fn arn(&self) -> std::option::Option<&str> {
        self.arn.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the definition was created.
    pub fn creation_timestamp(&self) -> std::option::Option<&str> {
        self.creation_timestamp.as_deref()
    }
    /// The ID of the definition.
    pub fn id(&self) -> std::option::Option<&str> {
        self.id.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the definition was last updated.
    pub fn last_updated_timestamp(&self) -> std::option::Option<&str> {
        self.last_updated_timestamp.as_deref()
    }
    /// The ID of the latest version associated with the definition.
    pub fn latest_version(&self) -> std::option::Option<&str> {
        self.latest_version.as_deref()
    }
    /// The ARN of the latest version associated with the definition.
    pub fn latest_version_arn(&self) -> std::option::Option<&str> {
        self.latest_version_arn.as_deref()
    }
    /// The name of the definition.
    pub fn name(&self) -> std::option::Option<&str> {
        self.name.as_deref()
    }
}
impl std::fmt::Debug for CreateGroupOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateGroupOutput");
        formatter.field("arn", &self.arn);
        formatter.field("creation_timestamp", &self.creation_timestamp);
        formatter.field("id", &self.id);
        formatter.field("last_updated_timestamp", &self.last_updated_timestamp);
        formatter.field("latest_version", &self.latest_version);
        formatter.field("latest_version_arn", &self.latest_version_arn);
        formatter.field("name", &self.name);
        formatter.finish()
    }
}
/// See [`CreateGroupOutput`](crate::output::CreateGroupOutput).
pub mod create_group_output {

    /// A builder for [`CreateGroupOutput`](crate::output::CreateGroupOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) arn: std::option::Option<std::string::String>,
        pub(crate) creation_timestamp: std::option::Option<std::string::String>,
        pub(crate) id: std::option::Option<std::string::String>,
        pub(crate) last_updated_timestamp: std::option::Option<std::string::String>,
        pub(crate) latest_version: std::option::Option<std::string::String>,
        pub(crate) latest_version_arn: std::option::Option<std::string::String>,
        pub(crate) name: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The ARN of the definition.
        pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.arn = Some(input.into());
            self
        }
        /// The ARN of the definition.
        pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.arn = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was created.
        pub fn creation_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.creation_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was created.
        pub fn set_creation_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.creation_timestamp = input;
            self
        }
        /// The ID of the definition.
        pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
            self.id = Some(input.into());
            self
        }
        /// The ID of the definition.
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.id = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was last updated.
        pub fn last_updated_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.last_updated_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was last updated.
        pub fn set_last_updated_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.last_updated_timestamp = input;
            self
        }
        /// The ID of the latest version associated with the definition.
        pub fn latest_version(mut self, input: impl Into<std::string::String>) -> Self {
            self.latest_version = Some(input.into());
            self
        }
        /// The ID of the latest version associated with the definition.
        pub fn set_latest_version(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.latest_version = input;
            self
        }
        /// The ARN of the latest version associated with the definition.
        pub fn latest_version_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.latest_version_arn = Some(input.into());
            self
        }
        /// The ARN of the latest version associated with the definition.
        pub fn set_latest_version_arn(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.latest_version_arn = input;
            self
        }
        /// The name of the definition.
        pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
            self.name = Some(input.into());
            self
        }
        /// The name of the definition.
        pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.name = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateGroupOutput`](crate::output::CreateGroupOutput).
        pub fn build(self) -> crate::output::CreateGroupOutput {
            crate::output::CreateGroupOutput {
                arn: self.arn,
                creation_timestamp: self.creation_timestamp,
                id: self.id,
                last_updated_timestamp: self.last_updated_timestamp,
                latest_version: self.latest_version,
                latest_version_arn: self.latest_version_arn,
                name: self.name,
            }
        }
    }
}
impl CreateGroupOutput {
    /// Creates a new builder-style object to manufacture [`CreateGroupOutput`](crate::output::CreateGroupOutput).
    pub fn builder() -> crate::output::create_group_output::Builder {
        crate::output::create_group_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateFunctionDefinitionVersionOutput {
    /// The ARN of the version.
    #[doc(hidden)]
    pub arn: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the version was created.
    #[doc(hidden)]
    pub creation_timestamp: std::option::Option<std::string::String>,
    /// The ID of the parent definition that the version is associated with.
    #[doc(hidden)]
    pub id: std::option::Option<std::string::String>,
    /// The ID of the version.
    #[doc(hidden)]
    pub version: std::option::Option<std::string::String>,
}
impl CreateFunctionDefinitionVersionOutput {
    /// The ARN of the version.
    pub fn arn(&self) -> std::option::Option<&str> {
        self.arn.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the version was created.
    pub fn creation_timestamp(&self) -> std::option::Option<&str> {
        self.creation_timestamp.as_deref()
    }
    /// The ID of the parent definition that the version is associated with.
    pub fn id(&self) -> std::option::Option<&str> {
        self.id.as_deref()
    }
    /// The ID of the version.
    pub fn version(&self) -> std::option::Option<&str> {
        self.version.as_deref()
    }
}
impl std::fmt::Debug for CreateFunctionDefinitionVersionOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateFunctionDefinitionVersionOutput");
        formatter.field("arn", &self.arn);
        formatter.field("creation_timestamp", &self.creation_timestamp);
        formatter.field("id", &self.id);
        formatter.field("version", &self.version);
        formatter.finish()
    }
}
/// See [`CreateFunctionDefinitionVersionOutput`](crate::output::CreateFunctionDefinitionVersionOutput).
pub mod create_function_definition_version_output {

    /// A builder for [`CreateFunctionDefinitionVersionOutput`](crate::output::CreateFunctionDefinitionVersionOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) arn: std::option::Option<std::string::String>,
        pub(crate) creation_timestamp: std::option::Option<std::string::String>,
        pub(crate) id: std::option::Option<std::string::String>,
        pub(crate) version: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The ARN of the version.
        pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.arn = Some(input.into());
            self
        }
        /// The ARN of the version.
        pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.arn = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the version was created.
        pub fn creation_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.creation_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the version was created.
        pub fn set_creation_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.creation_timestamp = input;
            self
        }
        /// The ID of the parent definition that the version is associated with.
        pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
            self.id = Some(input.into());
            self
        }
        /// The ID of the parent definition that the version is associated with.
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.id = input;
            self
        }
        /// The ID of the version.
        pub fn version(mut self, input: impl Into<std::string::String>) -> Self {
            self.version = Some(input.into());
            self
        }
        /// The ID of the version.
        pub fn set_version(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.version = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateFunctionDefinitionVersionOutput`](crate::output::CreateFunctionDefinitionVersionOutput).
        pub fn build(self) -> crate::output::CreateFunctionDefinitionVersionOutput {
            crate::output::CreateFunctionDefinitionVersionOutput {
                arn: self.arn,
                creation_timestamp: self.creation_timestamp,
                id: self.id,
                version: self.version,
            }
        }
    }
}
impl CreateFunctionDefinitionVersionOutput {
    /// Creates a new builder-style object to manufacture [`CreateFunctionDefinitionVersionOutput`](crate::output::CreateFunctionDefinitionVersionOutput).
    pub fn builder() -> crate::output::create_function_definition_version_output::Builder {
        crate::output::create_function_definition_version_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateFunctionDefinitionOutput {
    /// The ARN of the definition.
    #[doc(hidden)]
    pub arn: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the definition was created.
    #[doc(hidden)]
    pub creation_timestamp: std::option::Option<std::string::String>,
    /// The ID of the definition.
    #[doc(hidden)]
    pub id: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the definition was last updated.
    #[doc(hidden)]
    pub last_updated_timestamp: std::option::Option<std::string::String>,
    /// The ID of the latest version associated with the definition.
    #[doc(hidden)]
    pub latest_version: std::option::Option<std::string::String>,
    /// The ARN of the latest version associated with the definition.
    #[doc(hidden)]
    pub latest_version_arn: std::option::Option<std::string::String>,
    /// The name of the definition.
    #[doc(hidden)]
    pub name: std::option::Option<std::string::String>,
}
impl CreateFunctionDefinitionOutput {
    /// The ARN of the definition.
    pub fn arn(&self) -> std::option::Option<&str> {
        self.arn.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the definition was created.
    pub fn creation_timestamp(&self) -> std::option::Option<&str> {
        self.creation_timestamp.as_deref()
    }
    /// The ID of the definition.
    pub fn id(&self) -> std::option::Option<&str> {
        self.id.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the definition was last updated.
    pub fn last_updated_timestamp(&self) -> std::option::Option<&str> {
        self.last_updated_timestamp.as_deref()
    }
    /// The ID of the latest version associated with the definition.
    pub fn latest_version(&self) -> std::option::Option<&str> {
        self.latest_version.as_deref()
    }
    /// The ARN of the latest version associated with the definition.
    pub fn latest_version_arn(&self) -> std::option::Option<&str> {
        self.latest_version_arn.as_deref()
    }
    /// The name of the definition.
    pub fn name(&self) -> std::option::Option<&str> {
        self.name.as_deref()
    }
}
impl std::fmt::Debug for CreateFunctionDefinitionOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateFunctionDefinitionOutput");
        formatter.field("arn", &self.arn);
        formatter.field("creation_timestamp", &self.creation_timestamp);
        formatter.field("id", &self.id);
        formatter.field("last_updated_timestamp", &self.last_updated_timestamp);
        formatter.field("latest_version", &self.latest_version);
        formatter.field("latest_version_arn", &self.latest_version_arn);
        formatter.field("name", &self.name);
        formatter.finish()
    }
}
/// See [`CreateFunctionDefinitionOutput`](crate::output::CreateFunctionDefinitionOutput).
pub mod create_function_definition_output {

    /// A builder for [`CreateFunctionDefinitionOutput`](crate::output::CreateFunctionDefinitionOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) arn: std::option::Option<std::string::String>,
        pub(crate) creation_timestamp: std::option::Option<std::string::String>,
        pub(crate) id: std::option::Option<std::string::String>,
        pub(crate) last_updated_timestamp: std::option::Option<std::string::String>,
        pub(crate) latest_version: std::option::Option<std::string::String>,
        pub(crate) latest_version_arn: std::option::Option<std::string::String>,
        pub(crate) name: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The ARN of the definition.
        pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.arn = Some(input.into());
            self
        }
        /// The ARN of the definition.
        pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.arn = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was created.
        pub fn creation_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.creation_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was created.
        pub fn set_creation_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.creation_timestamp = input;
            self
        }
        /// The ID of the definition.
        pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
            self.id = Some(input.into());
            self
        }
        /// The ID of the definition.
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.id = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was last updated.
        pub fn last_updated_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.last_updated_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was last updated.
        pub fn set_last_updated_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.last_updated_timestamp = input;
            self
        }
        /// The ID of the latest version associated with the definition.
        pub fn latest_version(mut self, input: impl Into<std::string::String>) -> Self {
            self.latest_version = Some(input.into());
            self
        }
        /// The ID of the latest version associated with the definition.
        pub fn set_latest_version(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.latest_version = input;
            self
        }
        /// The ARN of the latest version associated with the definition.
        pub fn latest_version_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.latest_version_arn = Some(input.into());
            self
        }
        /// The ARN of the latest version associated with the definition.
        pub fn set_latest_version_arn(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.latest_version_arn = input;
            self
        }
        /// The name of the definition.
        pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
            self.name = Some(input.into());
            self
        }
        /// The name of the definition.
        pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.name = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateFunctionDefinitionOutput`](crate::output::CreateFunctionDefinitionOutput).
        pub fn build(self) -> crate::output::CreateFunctionDefinitionOutput {
            crate::output::CreateFunctionDefinitionOutput {
                arn: self.arn,
                creation_timestamp: self.creation_timestamp,
                id: self.id,
                last_updated_timestamp: self.last_updated_timestamp,
                latest_version: self.latest_version,
                latest_version_arn: self.latest_version_arn,
                name: self.name,
            }
        }
    }
}
impl CreateFunctionDefinitionOutput {
    /// Creates a new builder-style object to manufacture [`CreateFunctionDefinitionOutput`](crate::output::CreateFunctionDefinitionOutput).
    pub fn builder() -> crate::output::create_function_definition_output::Builder {
        crate::output::create_function_definition_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateDeviceDefinitionVersionOutput {
    /// The ARN of the version.
    #[doc(hidden)]
    pub arn: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the version was created.
    #[doc(hidden)]
    pub creation_timestamp: std::option::Option<std::string::String>,
    /// The ID of the parent definition that the version is associated with.
    #[doc(hidden)]
    pub id: std::option::Option<std::string::String>,
    /// The ID of the version.
    #[doc(hidden)]
    pub version: std::option::Option<std::string::String>,
}
impl CreateDeviceDefinitionVersionOutput {
    /// The ARN of the version.
    pub fn arn(&self) -> std::option::Option<&str> {
        self.arn.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the version was created.
    pub fn creation_timestamp(&self) -> std::option::Option<&str> {
        self.creation_timestamp.as_deref()
    }
    /// The ID of the parent definition that the version is associated with.
    pub fn id(&self) -> std::option::Option<&str> {
        self.id.as_deref()
    }
    /// The ID of the version.
    pub fn version(&self) -> std::option::Option<&str> {
        self.version.as_deref()
    }
}
impl std::fmt::Debug for CreateDeviceDefinitionVersionOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateDeviceDefinitionVersionOutput");
        formatter.field("arn", &self.arn);
        formatter.field("creation_timestamp", &self.creation_timestamp);
        formatter.field("id", &self.id);
        formatter.field("version", &self.version);
        formatter.finish()
    }
}
/// See [`CreateDeviceDefinitionVersionOutput`](crate::output::CreateDeviceDefinitionVersionOutput).
pub mod create_device_definition_version_output {

    /// A builder for [`CreateDeviceDefinitionVersionOutput`](crate::output::CreateDeviceDefinitionVersionOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) arn: std::option::Option<std::string::String>,
        pub(crate) creation_timestamp: std::option::Option<std::string::String>,
        pub(crate) id: std::option::Option<std::string::String>,
        pub(crate) version: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The ARN of the version.
        pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.arn = Some(input.into());
            self
        }
        /// The ARN of the version.
        pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.arn = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the version was created.
        pub fn creation_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.creation_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the version was created.
        pub fn set_creation_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.creation_timestamp = input;
            self
        }
        /// The ID of the parent definition that the version is associated with.
        pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
            self.id = Some(input.into());
            self
        }
        /// The ID of the parent definition that the version is associated with.
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.id = input;
            self
        }
        /// The ID of the version.
        pub fn version(mut self, input: impl Into<std::string::String>) -> Self {
            self.version = Some(input.into());
            self
        }
        /// The ID of the version.
        pub fn set_version(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.version = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateDeviceDefinitionVersionOutput`](crate::output::CreateDeviceDefinitionVersionOutput).
        pub fn build(self) -> crate::output::CreateDeviceDefinitionVersionOutput {
            crate::output::CreateDeviceDefinitionVersionOutput {
                arn: self.arn,
                creation_timestamp: self.creation_timestamp,
                id: self.id,
                version: self.version,
            }
        }
    }
}
impl CreateDeviceDefinitionVersionOutput {
    /// Creates a new builder-style object to manufacture [`CreateDeviceDefinitionVersionOutput`](crate::output::CreateDeviceDefinitionVersionOutput).
    pub fn builder() -> crate::output::create_device_definition_version_output::Builder {
        crate::output::create_device_definition_version_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateDeviceDefinitionOutput {
    /// The ARN of the definition.
    #[doc(hidden)]
    pub arn: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the definition was created.
    #[doc(hidden)]
    pub creation_timestamp: std::option::Option<std::string::String>,
    /// The ID of the definition.
    #[doc(hidden)]
    pub id: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the definition was last updated.
    #[doc(hidden)]
    pub last_updated_timestamp: std::option::Option<std::string::String>,
    /// The ID of the latest version associated with the definition.
    #[doc(hidden)]
    pub latest_version: std::option::Option<std::string::String>,
    /// The ARN of the latest version associated with the definition.
    #[doc(hidden)]
    pub latest_version_arn: std::option::Option<std::string::String>,
    /// The name of the definition.
    #[doc(hidden)]
    pub name: std::option::Option<std::string::String>,
}
impl CreateDeviceDefinitionOutput {
    /// The ARN of the definition.
    pub fn arn(&self) -> std::option::Option<&str> {
        self.arn.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the definition was created.
    pub fn creation_timestamp(&self) -> std::option::Option<&str> {
        self.creation_timestamp.as_deref()
    }
    /// The ID of the definition.
    pub fn id(&self) -> std::option::Option<&str> {
        self.id.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the definition was last updated.
    pub fn last_updated_timestamp(&self) -> std::option::Option<&str> {
        self.last_updated_timestamp.as_deref()
    }
    /// The ID of the latest version associated with the definition.
    pub fn latest_version(&self) -> std::option::Option<&str> {
        self.latest_version.as_deref()
    }
    /// The ARN of the latest version associated with the definition.
    pub fn latest_version_arn(&self) -> std::option::Option<&str> {
        self.latest_version_arn.as_deref()
    }
    /// The name of the definition.
    pub fn name(&self) -> std::option::Option<&str> {
        self.name.as_deref()
    }
}
impl std::fmt::Debug for CreateDeviceDefinitionOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateDeviceDefinitionOutput");
        formatter.field("arn", &self.arn);
        formatter.field("creation_timestamp", &self.creation_timestamp);
        formatter.field("id", &self.id);
        formatter.field("last_updated_timestamp", &self.last_updated_timestamp);
        formatter.field("latest_version", &self.latest_version);
        formatter.field("latest_version_arn", &self.latest_version_arn);
        formatter.field("name", &self.name);
        formatter.finish()
    }
}
/// See [`CreateDeviceDefinitionOutput`](crate::output::CreateDeviceDefinitionOutput).
pub mod create_device_definition_output {

    /// A builder for [`CreateDeviceDefinitionOutput`](crate::output::CreateDeviceDefinitionOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) arn: std::option::Option<std::string::String>,
        pub(crate) creation_timestamp: std::option::Option<std::string::String>,
        pub(crate) id: std::option::Option<std::string::String>,
        pub(crate) last_updated_timestamp: std::option::Option<std::string::String>,
        pub(crate) latest_version: std::option::Option<std::string::String>,
        pub(crate) latest_version_arn: std::option::Option<std::string::String>,
        pub(crate) name: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The ARN of the definition.
        pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.arn = Some(input.into());
            self
        }
        /// The ARN of the definition.
        pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.arn = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was created.
        pub fn creation_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.creation_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was created.
        pub fn set_creation_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.creation_timestamp = input;
            self
        }
        /// The ID of the definition.
        pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
            self.id = Some(input.into());
            self
        }
        /// The ID of the definition.
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.id = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was last updated.
        pub fn last_updated_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.last_updated_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was last updated.
        pub fn set_last_updated_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.last_updated_timestamp = input;
            self
        }
        /// The ID of the latest version associated with the definition.
        pub fn latest_version(mut self, input: impl Into<std::string::String>) -> Self {
            self.latest_version = Some(input.into());
            self
        }
        /// The ID of the latest version associated with the definition.
        pub fn set_latest_version(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.latest_version = input;
            self
        }
        /// The ARN of the latest version associated with the definition.
        pub fn latest_version_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.latest_version_arn = Some(input.into());
            self
        }
        /// The ARN of the latest version associated with the definition.
        pub fn set_latest_version_arn(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.latest_version_arn = input;
            self
        }
        /// The name of the definition.
        pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
            self.name = Some(input.into());
            self
        }
        /// The name of the definition.
        pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.name = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateDeviceDefinitionOutput`](crate::output::CreateDeviceDefinitionOutput).
        pub fn build(self) -> crate::output::CreateDeviceDefinitionOutput {
            crate::output::CreateDeviceDefinitionOutput {
                arn: self.arn,
                creation_timestamp: self.creation_timestamp,
                id: self.id,
                last_updated_timestamp: self.last_updated_timestamp,
                latest_version: self.latest_version,
                latest_version_arn: self.latest_version_arn,
                name: self.name,
            }
        }
    }
}
impl CreateDeviceDefinitionOutput {
    /// Creates a new builder-style object to manufacture [`CreateDeviceDefinitionOutput`](crate::output::CreateDeviceDefinitionOutput).
    pub fn builder() -> crate::output::create_device_definition_output::Builder {
        crate::output::create_device_definition_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateDeploymentOutput {
    /// The ARN of the deployment.
    #[doc(hidden)]
    pub deployment_arn: std::option::Option<std::string::String>,
    /// The ID of the deployment.
    #[doc(hidden)]
    pub deployment_id: std::option::Option<std::string::String>,
}
impl CreateDeploymentOutput {
    /// The ARN of the deployment.
    pub fn deployment_arn(&self) -> std::option::Option<&str> {
        self.deployment_arn.as_deref()
    }
    /// The ID of the deployment.
    pub fn deployment_id(&self) -> std::option::Option<&str> {
        self.deployment_id.as_deref()
    }
}
impl std::fmt::Debug for CreateDeploymentOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateDeploymentOutput");
        formatter.field("deployment_arn", &self.deployment_arn);
        formatter.field("deployment_id", &self.deployment_id);
        formatter.finish()
    }
}
/// See [`CreateDeploymentOutput`](crate::output::CreateDeploymentOutput).
pub mod create_deployment_output {

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateCoreDefinitionVersionOutput {
    /// The ARN of the version.
    #[doc(hidden)]
    pub arn: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the version was created.
    #[doc(hidden)]
    pub creation_timestamp: std::option::Option<std::string::String>,
    /// The ID of the parent definition that the version is associated with.
    #[doc(hidden)]
    pub id: std::option::Option<std::string::String>,
    /// The ID of the version.
    #[doc(hidden)]
    pub version: std::option::Option<std::string::String>,
}
impl CreateCoreDefinitionVersionOutput {
    /// The ARN of the version.
    pub fn arn(&self) -> std::option::Option<&str> {
        self.arn.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the version was created.
    pub fn creation_timestamp(&self) -> std::option::Option<&str> {
        self.creation_timestamp.as_deref()
    }
    /// The ID of the parent definition that the version is associated with.
    pub fn id(&self) -> std::option::Option<&str> {
        self.id.as_deref()
    }
    /// The ID of the version.
    pub fn version(&self) -> std::option::Option<&str> {
        self.version.as_deref()
    }
}
impl std::fmt::Debug for CreateCoreDefinitionVersionOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateCoreDefinitionVersionOutput");
        formatter.field("arn", &self.arn);
        formatter.field("creation_timestamp", &self.creation_timestamp);
        formatter.field("id", &self.id);
        formatter.field("version", &self.version);
        formatter.finish()
    }
}
/// See [`CreateCoreDefinitionVersionOutput`](crate::output::CreateCoreDefinitionVersionOutput).
pub mod create_core_definition_version_output {

    /// A builder for [`CreateCoreDefinitionVersionOutput`](crate::output::CreateCoreDefinitionVersionOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) arn: std::option::Option<std::string::String>,
        pub(crate) creation_timestamp: std::option::Option<std::string::String>,
        pub(crate) id: std::option::Option<std::string::String>,
        pub(crate) version: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The ARN of the version.
        pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.arn = Some(input.into());
            self
        }
        /// The ARN of the version.
        pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.arn = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the version was created.
        pub fn creation_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.creation_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the version was created.
        pub fn set_creation_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.creation_timestamp = input;
            self
        }
        /// The ID of the parent definition that the version is associated with.
        pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
            self.id = Some(input.into());
            self
        }
        /// The ID of the parent definition that the version is associated with.
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.id = input;
            self
        }
        /// The ID of the version.
        pub fn version(mut self, input: impl Into<std::string::String>) -> Self {
            self.version = Some(input.into());
            self
        }
        /// The ID of the version.
        pub fn set_version(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.version = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateCoreDefinitionVersionOutput`](crate::output::CreateCoreDefinitionVersionOutput).
        pub fn build(self) -> crate::output::CreateCoreDefinitionVersionOutput {
            crate::output::CreateCoreDefinitionVersionOutput {
                arn: self.arn,
                creation_timestamp: self.creation_timestamp,
                id: self.id,
                version: self.version,
            }
        }
    }
}
impl CreateCoreDefinitionVersionOutput {
    /// Creates a new builder-style object to manufacture [`CreateCoreDefinitionVersionOutput`](crate::output::CreateCoreDefinitionVersionOutput).
    pub fn builder() -> crate::output::create_core_definition_version_output::Builder {
        crate::output::create_core_definition_version_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateCoreDefinitionOutput {
    /// The ARN of the definition.
    #[doc(hidden)]
    pub arn: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the definition was created.
    #[doc(hidden)]
    pub creation_timestamp: std::option::Option<std::string::String>,
    /// The ID of the definition.
    #[doc(hidden)]
    pub id: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the definition was last updated.
    #[doc(hidden)]
    pub last_updated_timestamp: std::option::Option<std::string::String>,
    /// The ID of the latest version associated with the definition.
    #[doc(hidden)]
    pub latest_version: std::option::Option<std::string::String>,
    /// The ARN of the latest version associated with the definition.
    #[doc(hidden)]
    pub latest_version_arn: std::option::Option<std::string::String>,
    /// The name of the definition.
    #[doc(hidden)]
    pub name: std::option::Option<std::string::String>,
}
impl CreateCoreDefinitionOutput {
    /// The ARN of the definition.
    pub fn arn(&self) -> std::option::Option<&str> {
        self.arn.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the definition was created.
    pub fn creation_timestamp(&self) -> std::option::Option<&str> {
        self.creation_timestamp.as_deref()
    }
    /// The ID of the definition.
    pub fn id(&self) -> std::option::Option<&str> {
        self.id.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the definition was last updated.
    pub fn last_updated_timestamp(&self) -> std::option::Option<&str> {
        self.last_updated_timestamp.as_deref()
    }
    /// The ID of the latest version associated with the definition.
    pub fn latest_version(&self) -> std::option::Option<&str> {
        self.latest_version.as_deref()
    }
    /// The ARN of the latest version associated with the definition.
    pub fn latest_version_arn(&self) -> std::option::Option<&str> {
        self.latest_version_arn.as_deref()
    }
    /// The name of the definition.
    pub fn name(&self) -> std::option::Option<&str> {
        self.name.as_deref()
    }
}
impl std::fmt::Debug for CreateCoreDefinitionOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateCoreDefinitionOutput");
        formatter.field("arn", &self.arn);
        formatter.field("creation_timestamp", &self.creation_timestamp);
        formatter.field("id", &self.id);
        formatter.field("last_updated_timestamp", &self.last_updated_timestamp);
        formatter.field("latest_version", &self.latest_version);
        formatter.field("latest_version_arn", &self.latest_version_arn);
        formatter.field("name", &self.name);
        formatter.finish()
    }
}
/// See [`CreateCoreDefinitionOutput`](crate::output::CreateCoreDefinitionOutput).
pub mod create_core_definition_output {

    /// A builder for [`CreateCoreDefinitionOutput`](crate::output::CreateCoreDefinitionOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) arn: std::option::Option<std::string::String>,
        pub(crate) creation_timestamp: std::option::Option<std::string::String>,
        pub(crate) id: std::option::Option<std::string::String>,
        pub(crate) last_updated_timestamp: std::option::Option<std::string::String>,
        pub(crate) latest_version: std::option::Option<std::string::String>,
        pub(crate) latest_version_arn: std::option::Option<std::string::String>,
        pub(crate) name: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The ARN of the definition.
        pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.arn = Some(input.into());
            self
        }
        /// The ARN of the definition.
        pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.arn = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was created.
        pub fn creation_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.creation_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was created.
        pub fn set_creation_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.creation_timestamp = input;
            self
        }
        /// The ID of the definition.
        pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
            self.id = Some(input.into());
            self
        }
        /// The ID of the definition.
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.id = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was last updated.
        pub fn last_updated_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.last_updated_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was last updated.
        pub fn set_last_updated_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.last_updated_timestamp = input;
            self
        }
        /// The ID of the latest version associated with the definition.
        pub fn latest_version(mut self, input: impl Into<std::string::String>) -> Self {
            self.latest_version = Some(input.into());
            self
        }
        /// The ID of the latest version associated with the definition.
        pub fn set_latest_version(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.latest_version = input;
            self
        }
        /// The ARN of the latest version associated with the definition.
        pub fn latest_version_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.latest_version_arn = Some(input.into());
            self
        }
        /// The ARN of the latest version associated with the definition.
        pub fn set_latest_version_arn(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.latest_version_arn = input;
            self
        }
        /// The name of the definition.
        pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
            self.name = Some(input.into());
            self
        }
        /// The name of the definition.
        pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.name = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateCoreDefinitionOutput`](crate::output::CreateCoreDefinitionOutput).
        pub fn build(self) -> crate::output::CreateCoreDefinitionOutput {
            crate::output::CreateCoreDefinitionOutput {
                arn: self.arn,
                creation_timestamp: self.creation_timestamp,
                id: self.id,
                last_updated_timestamp: self.last_updated_timestamp,
                latest_version: self.latest_version,
                latest_version_arn: self.latest_version_arn,
                name: self.name,
            }
        }
    }
}
impl CreateCoreDefinitionOutput {
    /// Creates a new builder-style object to manufacture [`CreateCoreDefinitionOutput`](crate::output::CreateCoreDefinitionOutput).
    pub fn builder() -> crate::output::create_core_definition_output::Builder {
        crate::output::create_core_definition_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateConnectorDefinitionVersionOutput {
    /// The ARN of the version.
    #[doc(hidden)]
    pub arn: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the version was created.
    #[doc(hidden)]
    pub creation_timestamp: std::option::Option<std::string::String>,
    /// The ID of the parent definition that the version is associated with.
    #[doc(hidden)]
    pub id: std::option::Option<std::string::String>,
    /// The ID of the version.
    #[doc(hidden)]
    pub version: std::option::Option<std::string::String>,
}
impl CreateConnectorDefinitionVersionOutput {
    /// The ARN of the version.
    pub fn arn(&self) -> std::option::Option<&str> {
        self.arn.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the version was created.
    pub fn creation_timestamp(&self) -> std::option::Option<&str> {
        self.creation_timestamp.as_deref()
    }
    /// The ID of the parent definition that the version is associated with.
    pub fn id(&self) -> std::option::Option<&str> {
        self.id.as_deref()
    }
    /// The ID of the version.
    pub fn version(&self) -> std::option::Option<&str> {
        self.version.as_deref()
    }
}
impl std::fmt::Debug for CreateConnectorDefinitionVersionOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateConnectorDefinitionVersionOutput");
        formatter.field("arn", &self.arn);
        formatter.field("creation_timestamp", &self.creation_timestamp);
        formatter.field("id", &self.id);
        formatter.field("version", &self.version);
        formatter.finish()
    }
}
/// See [`CreateConnectorDefinitionVersionOutput`](crate::output::CreateConnectorDefinitionVersionOutput).
pub mod create_connector_definition_version_output {

    /// A builder for [`CreateConnectorDefinitionVersionOutput`](crate::output::CreateConnectorDefinitionVersionOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) arn: std::option::Option<std::string::String>,
        pub(crate) creation_timestamp: std::option::Option<std::string::String>,
        pub(crate) id: std::option::Option<std::string::String>,
        pub(crate) version: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The ARN of the version.
        pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.arn = Some(input.into());
            self
        }
        /// The ARN of the version.
        pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.arn = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the version was created.
        pub fn creation_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.creation_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the version was created.
        pub fn set_creation_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.creation_timestamp = input;
            self
        }
        /// The ID of the parent definition that the version is associated with.
        pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
            self.id = Some(input.into());
            self
        }
        /// The ID of the parent definition that the version is associated with.
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.id = input;
            self
        }
        /// The ID of the version.
        pub fn version(mut self, input: impl Into<std::string::String>) -> Self {
            self.version = Some(input.into());
            self
        }
        /// The ID of the version.
        pub fn set_version(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.version = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateConnectorDefinitionVersionOutput`](crate::output::CreateConnectorDefinitionVersionOutput).
        pub fn build(self) -> crate::output::CreateConnectorDefinitionVersionOutput {
            crate::output::CreateConnectorDefinitionVersionOutput {
                arn: self.arn,
                creation_timestamp: self.creation_timestamp,
                id: self.id,
                version: self.version,
            }
        }
    }
}
impl CreateConnectorDefinitionVersionOutput {
    /// Creates a new builder-style object to manufacture [`CreateConnectorDefinitionVersionOutput`](crate::output::CreateConnectorDefinitionVersionOutput).
    pub fn builder() -> crate::output::create_connector_definition_version_output::Builder {
        crate::output::create_connector_definition_version_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateConnectorDefinitionOutput {
    /// The ARN of the definition.
    #[doc(hidden)]
    pub arn: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the definition was created.
    #[doc(hidden)]
    pub creation_timestamp: std::option::Option<std::string::String>,
    /// The ID of the definition.
    #[doc(hidden)]
    pub id: std::option::Option<std::string::String>,
    /// The time, in milliseconds since the epoch, when the definition was last updated.
    #[doc(hidden)]
    pub last_updated_timestamp: std::option::Option<std::string::String>,
    /// The ID of the latest version associated with the definition.
    #[doc(hidden)]
    pub latest_version: std::option::Option<std::string::String>,
    /// The ARN of the latest version associated with the definition.
    #[doc(hidden)]
    pub latest_version_arn: std::option::Option<std::string::String>,
    /// The name of the definition.
    #[doc(hidden)]
    pub name: std::option::Option<std::string::String>,
}
impl CreateConnectorDefinitionOutput {
    /// The ARN of the definition.
    pub fn arn(&self) -> std::option::Option<&str> {
        self.arn.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the definition was created.
    pub fn creation_timestamp(&self) -> std::option::Option<&str> {
        self.creation_timestamp.as_deref()
    }
    /// The ID of the definition.
    pub fn id(&self) -> std::option::Option<&str> {
        self.id.as_deref()
    }
    /// The time, in milliseconds since the epoch, when the definition was last updated.
    pub fn last_updated_timestamp(&self) -> std::option::Option<&str> {
        self.last_updated_timestamp.as_deref()
    }
    /// The ID of the latest version associated with the definition.
    pub fn latest_version(&self) -> std::option::Option<&str> {
        self.latest_version.as_deref()
    }
    /// The ARN of the latest version associated with the definition.
    pub fn latest_version_arn(&self) -> std::option::Option<&str> {
        self.latest_version_arn.as_deref()
    }
    /// The name of the definition.
    pub fn name(&self) -> std::option::Option<&str> {
        self.name.as_deref()
    }
}
impl std::fmt::Debug for CreateConnectorDefinitionOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateConnectorDefinitionOutput");
        formatter.field("arn", &self.arn);
        formatter.field("creation_timestamp", &self.creation_timestamp);
        formatter.field("id", &self.id);
        formatter.field("last_updated_timestamp", &self.last_updated_timestamp);
        formatter.field("latest_version", &self.latest_version);
        formatter.field("latest_version_arn", &self.latest_version_arn);
        formatter.field("name", &self.name);
        formatter.finish()
    }
}
/// See [`CreateConnectorDefinitionOutput`](crate::output::CreateConnectorDefinitionOutput).
pub mod create_connector_definition_output {

    /// A builder for [`CreateConnectorDefinitionOutput`](crate::output::CreateConnectorDefinitionOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) arn: std::option::Option<std::string::String>,
        pub(crate) creation_timestamp: std::option::Option<std::string::String>,
        pub(crate) id: std::option::Option<std::string::String>,
        pub(crate) last_updated_timestamp: std::option::Option<std::string::String>,
        pub(crate) latest_version: std::option::Option<std::string::String>,
        pub(crate) latest_version_arn: std::option::Option<std::string::String>,
        pub(crate) name: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The ARN of the definition.
        pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.arn = Some(input.into());
            self
        }
        /// The ARN of the definition.
        pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.arn = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was created.
        pub fn creation_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.creation_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was created.
        pub fn set_creation_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.creation_timestamp = input;
            self
        }
        /// The ID of the definition.
        pub fn id(mut self, input: impl Into<std::string::String>) -> Self {
            self.id = Some(input.into());
            self
        }
        /// The ID of the definition.
        pub fn set_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.id = input;
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was last updated.
        pub fn last_updated_timestamp(mut self, input: impl Into<std::string::String>) -> Self {
            self.last_updated_timestamp = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the definition was last updated.
        pub fn set_last_updated_timestamp(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.last_updated_timestamp = input;
            self
        }
        /// The ID of the latest version associated with the definition.
        pub fn latest_version(mut self, input: impl Into<std::string::String>) -> Self {
            self.latest_version = Some(input.into());
            self
        }
        /// The ID of the latest version associated with the definition.
        pub fn set_latest_version(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.latest_version = input;
            self
        }
        /// The ARN of the latest version associated with the definition.
        pub fn latest_version_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.latest_version_arn = Some(input.into());
            self
        }
        /// The ARN of the latest version associated with the definition.
        pub fn set_latest_version_arn(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.latest_version_arn = input;
            self
        }
        /// The name of the definition.
        pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
            self.name = Some(input.into());
            self
        }
        /// The name of the definition.
        pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.name = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateConnectorDefinitionOutput`](crate::output::CreateConnectorDefinitionOutput).
        pub fn build(self) -> crate::output::CreateConnectorDefinitionOutput {
            crate::output::CreateConnectorDefinitionOutput {
                arn: self.arn,
                creation_timestamp: self.creation_timestamp,
                id: self.id,
                last_updated_timestamp: self.last_updated_timestamp,
                latest_version: self.latest_version,
                latest_version_arn: self.latest_version_arn,
                name: self.name,
            }
        }
    }
}
impl CreateConnectorDefinitionOutput {
    /// Creates a new builder-style object to manufacture [`CreateConnectorDefinitionOutput`](crate::output::CreateConnectorDefinitionOutput).
    pub fn builder() -> crate::output::create_connector_definition_output::Builder {
        crate::output::create_connector_definition_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct AssociateServiceRoleToAccountOutput {
    /// The time when the service role was associated with the account.
    #[doc(hidden)]
    pub associated_at: std::option::Option<std::string::String>,
}
impl AssociateServiceRoleToAccountOutput {
    /// The time when the service role was associated with the account.
    pub fn associated_at(&self) -> std::option::Option<&str> {
        self.associated_at.as_deref()
    }
}
impl std::fmt::Debug for AssociateServiceRoleToAccountOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("AssociateServiceRoleToAccountOutput");
        formatter.field("associated_at", &self.associated_at);
        formatter.finish()
    }
}
/// See [`AssociateServiceRoleToAccountOutput`](crate::output::AssociateServiceRoleToAccountOutput).
pub mod associate_service_role_to_account_output {

    /// A builder for [`AssociateServiceRoleToAccountOutput`](crate::output::AssociateServiceRoleToAccountOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) associated_at: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The time when the service role was associated with the account.
        pub fn associated_at(mut self, input: impl Into<std::string::String>) -> Self {
            self.associated_at = Some(input.into());
            self
        }
        /// The time when the service role was associated with the account.
        pub fn set_associated_at(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.associated_at = input;
            self
        }
        /// Consumes the builder and constructs a [`AssociateServiceRoleToAccountOutput`](crate::output::AssociateServiceRoleToAccountOutput).
        pub fn build(self) -> crate::output::AssociateServiceRoleToAccountOutput {
            crate::output::AssociateServiceRoleToAccountOutput {
                associated_at: self.associated_at,
            }
        }
    }
}
impl AssociateServiceRoleToAccountOutput {
    /// Creates a new builder-style object to manufacture [`AssociateServiceRoleToAccountOutput`](crate::output::AssociateServiceRoleToAccountOutput).
    pub fn builder() -> crate::output::associate_service_role_to_account_output::Builder {
        crate::output::associate_service_role_to_account_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct AssociateRoleToGroupOutput {
    /// The time, in milliseconds since the epoch, when the role ARN was associated with the group.
    #[doc(hidden)]
    pub associated_at: std::option::Option<std::string::String>,
}
impl AssociateRoleToGroupOutput {
    /// The time, in milliseconds since the epoch, when the role ARN was associated with the group.
    pub fn associated_at(&self) -> std::option::Option<&str> {
        self.associated_at.as_deref()
    }
}
impl std::fmt::Debug for AssociateRoleToGroupOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("AssociateRoleToGroupOutput");
        formatter.field("associated_at", &self.associated_at);
        formatter.finish()
    }
}
/// See [`AssociateRoleToGroupOutput`](crate::output::AssociateRoleToGroupOutput).
pub mod associate_role_to_group_output {

    /// A builder for [`AssociateRoleToGroupOutput`](crate::output::AssociateRoleToGroupOutput).
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) associated_at: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// The time, in milliseconds since the epoch, when the role ARN was associated with the group.
        pub fn associated_at(mut self, input: impl Into<std::string::String>) -> Self {
            self.associated_at = Some(input.into());
            self
        }
        /// The time, in milliseconds since the epoch, when the role ARN was associated with the group.
        pub fn set_associated_at(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.associated_at = input;
            self
        }
        /// Consumes the builder and constructs a [`AssociateRoleToGroupOutput`](crate::output::AssociateRoleToGroupOutput).
        pub fn build(self) -> crate::output::AssociateRoleToGroupOutput {
            crate::output::AssociateRoleToGroupOutput {
                associated_at: self.associated_at,
            }
        }
    }
}
impl AssociateRoleToGroupOutput {
    /// Creates a new builder-style object to manufacture [`AssociateRoleToGroupOutput`](crate::output::AssociateRoleToGroupOutput).
    pub fn builder() -> crate::output::associate_role_to_group_output::Builder {
        crate::output::associate_role_to_group_output::Builder::default()
    }
}