aws-sdk-proton 0.24.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, std::fmt::Debug)]
pub struct CreateTemplateSyncConfigOutput {
    /// <p>The template sync configuration detail data that's returned by Proton.</p>
    #[doc(hidden)]
    pub template_sync_config: std::option::Option<crate::model::TemplateSyncConfig>,
}
impl CreateTemplateSyncConfigOutput {
    /// <p>The template sync configuration detail data that's returned by Proton.</p>
    pub fn template_sync_config(&self) -> std::option::Option<&crate::model::TemplateSyncConfig> {
        self.template_sync_config.as_ref()
    }
}
/// See [`CreateTemplateSyncConfigOutput`](crate::output::CreateTemplateSyncConfigOutput).
pub mod create_template_sync_config_output {

    /// A builder for [`CreateTemplateSyncConfigOutput`](crate::output::CreateTemplateSyncConfigOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) template_sync_config: std::option::Option<crate::model::TemplateSyncConfig>,
    }
    impl Builder {
        /// <p>The template sync configuration detail data that's returned by Proton.</p>
        pub fn template_sync_config(mut self, input: crate::model::TemplateSyncConfig) -> Self {
            self.template_sync_config = Some(input);
            self
        }
        /// <p>The template sync configuration detail data that's returned by Proton.</p>
        pub fn set_template_sync_config(
            mut self,
            input: std::option::Option<crate::model::TemplateSyncConfig>,
        ) -> Self {
            self.template_sync_config = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateTemplateSyncConfigOutput`](crate::output::CreateTemplateSyncConfigOutput).
        pub fn build(self) -> crate::output::CreateTemplateSyncConfigOutput {
            crate::output::CreateTemplateSyncConfigOutput {
                template_sync_config: self.template_sync_config,
            }
        }
    }
}
impl CreateTemplateSyncConfigOutput {
    /// Creates a new builder-style object to manufacture [`CreateTemplateSyncConfigOutput`](crate::output::CreateTemplateSyncConfigOutput).
    pub fn builder() -> crate::output::create_template_sync_config_output::Builder {
        crate::output::create_template_sync_config_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteTemplateSyncConfigOutput {
    /// <p>The template sync configuration detail data that's returned by Proton.</p>
    #[doc(hidden)]
    pub template_sync_config: std::option::Option<crate::model::TemplateSyncConfig>,
}
impl DeleteTemplateSyncConfigOutput {
    /// <p>The template sync configuration detail data that's returned by Proton.</p>
    pub fn template_sync_config(&self) -> std::option::Option<&crate::model::TemplateSyncConfig> {
        self.template_sync_config.as_ref()
    }
}
/// See [`DeleteTemplateSyncConfigOutput`](crate::output::DeleteTemplateSyncConfigOutput).
pub mod delete_template_sync_config_output {

    /// A builder for [`DeleteTemplateSyncConfigOutput`](crate::output::DeleteTemplateSyncConfigOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) template_sync_config: std::option::Option<crate::model::TemplateSyncConfig>,
    }
    impl Builder {
        /// <p>The template sync configuration detail data that's returned by Proton.</p>
        pub fn template_sync_config(mut self, input: crate::model::TemplateSyncConfig) -> Self {
            self.template_sync_config = Some(input);
            self
        }
        /// <p>The template sync configuration detail data that's returned by Proton.</p>
        pub fn set_template_sync_config(
            mut self,
            input: std::option::Option<crate::model::TemplateSyncConfig>,
        ) -> Self {
            self.template_sync_config = input;
            self
        }
        /// Consumes the builder and constructs a [`DeleteTemplateSyncConfigOutput`](crate::output::DeleteTemplateSyncConfigOutput).
        pub fn build(self) -> crate::output::DeleteTemplateSyncConfigOutput {
            crate::output::DeleteTemplateSyncConfigOutput {
                template_sync_config: self.template_sync_config,
            }
        }
    }
}
impl DeleteTemplateSyncConfigOutput {
    /// Creates a new builder-style object to manufacture [`DeleteTemplateSyncConfigOutput`](crate::output::DeleteTemplateSyncConfigOutput).
    pub fn builder() -> crate::output::delete_template_sync_config_output::Builder {
        crate::output::delete_template_sync_config_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateTemplateSyncConfigOutput {
    /// <p>The template sync configuration detail data that's returned by Proton.</p>
    #[doc(hidden)]
    pub template_sync_config: std::option::Option<crate::model::TemplateSyncConfig>,
}
impl UpdateTemplateSyncConfigOutput {
    /// <p>The template sync configuration detail data that's returned by Proton.</p>
    pub fn template_sync_config(&self) -> std::option::Option<&crate::model::TemplateSyncConfig> {
        self.template_sync_config.as_ref()
    }
}
/// See [`UpdateTemplateSyncConfigOutput`](crate::output::UpdateTemplateSyncConfigOutput).
pub mod update_template_sync_config_output {

    /// A builder for [`UpdateTemplateSyncConfigOutput`](crate::output::UpdateTemplateSyncConfigOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) template_sync_config: std::option::Option<crate::model::TemplateSyncConfig>,
    }
    impl Builder {
        /// <p>The template sync configuration detail data that's returned by Proton.</p>
        pub fn template_sync_config(mut self, input: crate::model::TemplateSyncConfig) -> Self {
            self.template_sync_config = Some(input);
            self
        }
        /// <p>The template sync configuration detail data that's returned by Proton.</p>
        pub fn set_template_sync_config(
            mut self,
            input: std::option::Option<crate::model::TemplateSyncConfig>,
        ) -> Self {
            self.template_sync_config = input;
            self
        }
        /// Consumes the builder and constructs a [`UpdateTemplateSyncConfigOutput`](crate::output::UpdateTemplateSyncConfigOutput).
        pub fn build(self) -> crate::output::UpdateTemplateSyncConfigOutput {
            crate::output::UpdateTemplateSyncConfigOutput {
                template_sync_config: self.template_sync_config,
            }
        }
    }
}
impl UpdateTemplateSyncConfigOutput {
    /// Creates a new builder-style object to manufacture [`UpdateTemplateSyncConfigOutput`](crate::output::UpdateTemplateSyncConfigOutput).
    pub fn builder() -> crate::output::update_template_sync_config_output::Builder {
        crate::output::update_template_sync_config_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetTemplateSyncConfigOutput {
    /// <p>The template sync configuration detail data that's returned by Proton.</p>
    #[doc(hidden)]
    pub template_sync_config: std::option::Option<crate::model::TemplateSyncConfig>,
}
impl GetTemplateSyncConfigOutput {
    /// <p>The template sync configuration detail data that's returned by Proton.</p>
    pub fn template_sync_config(&self) -> std::option::Option<&crate::model::TemplateSyncConfig> {
        self.template_sync_config.as_ref()
    }
}
/// See [`GetTemplateSyncConfigOutput`](crate::output::GetTemplateSyncConfigOutput).
pub mod get_template_sync_config_output {

    /// A builder for [`GetTemplateSyncConfigOutput`](crate::output::GetTemplateSyncConfigOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) template_sync_config: std::option::Option<crate::model::TemplateSyncConfig>,
    }
    impl Builder {
        /// <p>The template sync configuration detail data that's returned by Proton.</p>
        pub fn template_sync_config(mut self, input: crate::model::TemplateSyncConfig) -> Self {
            self.template_sync_config = Some(input);
            self
        }
        /// <p>The template sync configuration detail data that's returned by Proton.</p>
        pub fn set_template_sync_config(
            mut self,
            input: std::option::Option<crate::model::TemplateSyncConfig>,
        ) -> Self {
            self.template_sync_config = input;
            self
        }
        /// Consumes the builder and constructs a [`GetTemplateSyncConfigOutput`](crate::output::GetTemplateSyncConfigOutput).
        pub fn build(self) -> crate::output::GetTemplateSyncConfigOutput {
            crate::output::GetTemplateSyncConfigOutput {
                template_sync_config: self.template_sync_config,
            }
        }
    }
}
impl GetTemplateSyncConfigOutput {
    /// Creates a new builder-style object to manufacture [`GetTemplateSyncConfigOutput`](crate::output::GetTemplateSyncConfigOutput).
    pub fn builder() -> crate::output::get_template_sync_config_output::Builder {
        crate::output::get_template_sync_config_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListServiceTemplateVersionsOutput {
    /// <p>A token that indicates the location of the next major or minor version in the array of major or minor versions of a service template, after the current requested list of service major or minor versions.</p>
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
    /// <p>An array of major or minor versions of a service template with detail data.</p>
    #[doc(hidden)]
    pub template_versions:
        std::option::Option<std::vec::Vec<crate::model::ServiceTemplateVersionSummary>>,
}
impl ListServiceTemplateVersionsOutput {
    /// <p>A token that indicates the location of the next major or minor version in the array of major or minor versions of a service template, after the current requested list of service major or minor versions.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// <p>An array of major or minor versions of a service template with detail data.</p>
    pub fn template_versions(
        &self,
    ) -> std::option::Option<&[crate::model::ServiceTemplateVersionSummary]> {
        self.template_versions.as_deref()
    }
}
/// See [`ListServiceTemplateVersionsOutput`](crate::output::ListServiceTemplateVersionsOutput).
pub mod list_service_template_versions_output {

    /// A builder for [`ListServiceTemplateVersionsOutput`](crate::output::ListServiceTemplateVersionsOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) template_versions:
            std::option::Option<std::vec::Vec<crate::model::ServiceTemplateVersionSummary>>,
    }
    impl Builder {
        /// <p>A token that indicates the location of the next major or minor version in the array of major or minor versions of a service template, after the current requested list of service major or minor versions.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>A token that indicates the location of the next major or minor version in the array of major or minor versions of a service template, after the current requested list of service major or minor versions.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Appends an item to `template_versions`.
        ///
        /// To override the contents of this collection use [`set_template_versions`](Self::set_template_versions).
        ///
        /// <p>An array of major or minor versions of a service template with detail data.</p>
        pub fn template_versions(
            mut self,
            input: crate::model::ServiceTemplateVersionSummary,
        ) -> Self {
            let mut v = self.template_versions.unwrap_or_default();
            v.push(input);
            self.template_versions = Some(v);
            self
        }
        /// <p>An array of major or minor versions of a service template with detail data.</p>
        pub fn set_template_versions(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ServiceTemplateVersionSummary>>,
        ) -> Self {
            self.template_versions = input;
            self
        }
        /// Consumes the builder and constructs a [`ListServiceTemplateVersionsOutput`](crate::output::ListServiceTemplateVersionsOutput).
        pub fn build(self) -> crate::output::ListServiceTemplateVersionsOutput {
            crate::output::ListServiceTemplateVersionsOutput {
                next_token: self.next_token,
                template_versions: self.template_versions,
            }
        }
    }
}
impl ListServiceTemplateVersionsOutput {
    /// Creates a new builder-style object to manufacture [`ListServiceTemplateVersionsOutput`](crate::output::ListServiceTemplateVersionsOutput).
    pub fn builder() -> crate::output::list_service_template_versions_output::Builder {
        crate::output::list_service_template_versions_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateServiceTemplateVersionOutput {
    /// <p>The service template version summary of detail data that's returned by Proton.</p>
    #[doc(hidden)]
    pub service_template_version: std::option::Option<crate::model::ServiceTemplateVersion>,
}
impl CreateServiceTemplateVersionOutput {
    /// <p>The service template version summary of detail data that's returned by Proton.</p>
    pub fn service_template_version(
        &self,
    ) -> std::option::Option<&crate::model::ServiceTemplateVersion> {
        self.service_template_version.as_ref()
    }
}
/// See [`CreateServiceTemplateVersionOutput`](crate::output::CreateServiceTemplateVersionOutput).
pub mod create_service_template_version_output {

    /// A builder for [`CreateServiceTemplateVersionOutput`](crate::output::CreateServiceTemplateVersionOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) service_template_version:
            std::option::Option<crate::model::ServiceTemplateVersion>,
    }
    impl Builder {
        /// <p>The service template version summary of detail data that's returned by Proton.</p>
        pub fn service_template_version(
            mut self,
            input: crate::model::ServiceTemplateVersion,
        ) -> Self {
            self.service_template_version = Some(input);
            self
        }
        /// <p>The service template version summary of detail data that's returned by Proton.</p>
        pub fn set_service_template_version(
            mut self,
            input: std::option::Option<crate::model::ServiceTemplateVersion>,
        ) -> Self {
            self.service_template_version = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateServiceTemplateVersionOutput`](crate::output::CreateServiceTemplateVersionOutput).
        pub fn build(self) -> crate::output::CreateServiceTemplateVersionOutput {
            crate::output::CreateServiceTemplateVersionOutput {
                service_template_version: self.service_template_version,
            }
        }
    }
}
impl CreateServiceTemplateVersionOutput {
    /// Creates a new builder-style object to manufacture [`CreateServiceTemplateVersionOutput`](crate::output::CreateServiceTemplateVersionOutput).
    pub fn builder() -> crate::output::create_service_template_version_output::Builder {
        crate::output::create_service_template_version_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteServiceTemplateVersionOutput {
    /// <p>The detailed data of the service template version being deleted.</p>
    #[doc(hidden)]
    pub service_template_version: std::option::Option<crate::model::ServiceTemplateVersion>,
}
impl DeleteServiceTemplateVersionOutput {
    /// <p>The detailed data of the service template version being deleted.</p>
    pub fn service_template_version(
        &self,
    ) -> std::option::Option<&crate::model::ServiceTemplateVersion> {
        self.service_template_version.as_ref()
    }
}
/// See [`DeleteServiceTemplateVersionOutput`](crate::output::DeleteServiceTemplateVersionOutput).
pub mod delete_service_template_version_output {

    /// A builder for [`DeleteServiceTemplateVersionOutput`](crate::output::DeleteServiceTemplateVersionOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) service_template_version:
            std::option::Option<crate::model::ServiceTemplateVersion>,
    }
    impl Builder {
        /// <p>The detailed data of the service template version being deleted.</p>
        pub fn service_template_version(
            mut self,
            input: crate::model::ServiceTemplateVersion,
        ) -> Self {
            self.service_template_version = Some(input);
            self
        }
        /// <p>The detailed data of the service template version being deleted.</p>
        pub fn set_service_template_version(
            mut self,
            input: std::option::Option<crate::model::ServiceTemplateVersion>,
        ) -> Self {
            self.service_template_version = input;
            self
        }
        /// Consumes the builder and constructs a [`DeleteServiceTemplateVersionOutput`](crate::output::DeleteServiceTemplateVersionOutput).
        pub fn build(self) -> crate::output::DeleteServiceTemplateVersionOutput {
            crate::output::DeleteServiceTemplateVersionOutput {
                service_template_version: self.service_template_version,
            }
        }
    }
}
impl DeleteServiceTemplateVersionOutput {
    /// Creates a new builder-style object to manufacture [`DeleteServiceTemplateVersionOutput`](crate::output::DeleteServiceTemplateVersionOutput).
    pub fn builder() -> crate::output::delete_service_template_version_output::Builder {
        crate::output::delete_service_template_version_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateServiceTemplateVersionOutput {
    /// <p>The service template version detail data that's returned by Proton.</p>
    #[doc(hidden)]
    pub service_template_version: std::option::Option<crate::model::ServiceTemplateVersion>,
}
impl UpdateServiceTemplateVersionOutput {
    /// <p>The service template version detail data that's returned by Proton.</p>
    pub fn service_template_version(
        &self,
    ) -> std::option::Option<&crate::model::ServiceTemplateVersion> {
        self.service_template_version.as_ref()
    }
}
/// See [`UpdateServiceTemplateVersionOutput`](crate::output::UpdateServiceTemplateVersionOutput).
pub mod update_service_template_version_output {

    /// A builder for [`UpdateServiceTemplateVersionOutput`](crate::output::UpdateServiceTemplateVersionOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) service_template_version:
            std::option::Option<crate::model::ServiceTemplateVersion>,
    }
    impl Builder {
        /// <p>The service template version detail data that's returned by Proton.</p>
        pub fn service_template_version(
            mut self,
            input: crate::model::ServiceTemplateVersion,
        ) -> Self {
            self.service_template_version = Some(input);
            self
        }
        /// <p>The service template version detail data that's returned by Proton.</p>
        pub fn set_service_template_version(
            mut self,
            input: std::option::Option<crate::model::ServiceTemplateVersion>,
        ) -> Self {
            self.service_template_version = input;
            self
        }
        /// Consumes the builder and constructs a [`UpdateServiceTemplateVersionOutput`](crate::output::UpdateServiceTemplateVersionOutput).
        pub fn build(self) -> crate::output::UpdateServiceTemplateVersionOutput {
            crate::output::UpdateServiceTemplateVersionOutput {
                service_template_version: self.service_template_version,
            }
        }
    }
}
impl UpdateServiceTemplateVersionOutput {
    /// Creates a new builder-style object to manufacture [`UpdateServiceTemplateVersionOutput`](crate::output::UpdateServiceTemplateVersionOutput).
    pub fn builder() -> crate::output::update_service_template_version_output::Builder {
        crate::output::update_service_template_version_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetServiceTemplateVersionOutput {
    /// <p>The detailed data of the requested service template version.</p>
    #[doc(hidden)]
    pub service_template_version: std::option::Option<crate::model::ServiceTemplateVersion>,
}
impl GetServiceTemplateVersionOutput {
    /// <p>The detailed data of the requested service template version.</p>
    pub fn service_template_version(
        &self,
    ) -> std::option::Option<&crate::model::ServiceTemplateVersion> {
        self.service_template_version.as_ref()
    }
}
/// See [`GetServiceTemplateVersionOutput`](crate::output::GetServiceTemplateVersionOutput).
pub mod get_service_template_version_output {

    /// A builder for [`GetServiceTemplateVersionOutput`](crate::output::GetServiceTemplateVersionOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) service_template_version:
            std::option::Option<crate::model::ServiceTemplateVersion>,
    }
    impl Builder {
        /// <p>The detailed data of the requested service template version.</p>
        pub fn service_template_version(
            mut self,
            input: crate::model::ServiceTemplateVersion,
        ) -> Self {
            self.service_template_version = Some(input);
            self
        }
        /// <p>The detailed data of the requested service template version.</p>
        pub fn set_service_template_version(
            mut self,
            input: std::option::Option<crate::model::ServiceTemplateVersion>,
        ) -> Self {
            self.service_template_version = input;
            self
        }
        /// Consumes the builder and constructs a [`GetServiceTemplateVersionOutput`](crate::output::GetServiceTemplateVersionOutput).
        pub fn build(self) -> crate::output::GetServiceTemplateVersionOutput {
            crate::output::GetServiceTemplateVersionOutput {
                service_template_version: self.service_template_version,
            }
        }
    }
}
impl GetServiceTemplateVersionOutput {
    /// Creates a new builder-style object to manufacture [`GetServiceTemplateVersionOutput`](crate::output::GetServiceTemplateVersionOutput).
    pub fn builder() -> crate::output::get_service_template_version_output::Builder {
        crate::output::get_service_template_version_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListServiceTemplatesOutput {
    /// <p>A token that indicates the location of the next service template in the array of service templates, after the current requested list of service templates.</p>
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
    /// <p>An array of service templates with detail data.</p>
    #[doc(hidden)]
    pub templates: std::option::Option<std::vec::Vec<crate::model::ServiceTemplateSummary>>,
}
impl ListServiceTemplatesOutput {
    /// <p>A token that indicates the location of the next service template in the array of service templates, after the current requested list of service templates.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// <p>An array of service templates with detail data.</p>
    pub fn templates(&self) -> std::option::Option<&[crate::model::ServiceTemplateSummary]> {
        self.templates.as_deref()
    }
}
/// See [`ListServiceTemplatesOutput`](crate::output::ListServiceTemplatesOutput).
pub mod list_service_templates_output {

    /// A builder for [`ListServiceTemplatesOutput`](crate::output::ListServiceTemplatesOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) templates:
            std::option::Option<std::vec::Vec<crate::model::ServiceTemplateSummary>>,
    }
    impl Builder {
        /// <p>A token that indicates the location of the next service template in the array of service templates, after the current requested list of service templates.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>A token that indicates the location of the next service template in the array of service templates, after the current requested list of service templates.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Appends an item to `templates`.
        ///
        /// To override the contents of this collection use [`set_templates`](Self::set_templates).
        ///
        /// <p>An array of service templates with detail data.</p>
        pub fn templates(mut self, input: crate::model::ServiceTemplateSummary) -> Self {
            let mut v = self.templates.unwrap_or_default();
            v.push(input);
            self.templates = Some(v);
            self
        }
        /// <p>An array of service templates with detail data.</p>
        pub fn set_templates(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ServiceTemplateSummary>>,
        ) -> Self {
            self.templates = input;
            self
        }
        /// Consumes the builder and constructs a [`ListServiceTemplatesOutput`](crate::output::ListServiceTemplatesOutput).
        pub fn build(self) -> crate::output::ListServiceTemplatesOutput {
            crate::output::ListServiceTemplatesOutput {
                next_token: self.next_token,
                templates: self.templates,
            }
        }
    }
}
impl ListServiceTemplatesOutput {
    /// Creates a new builder-style object to manufacture [`ListServiceTemplatesOutput`](crate::output::ListServiceTemplatesOutput).
    pub fn builder() -> crate::output::list_service_templates_output::Builder {
        crate::output::list_service_templates_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateServiceTemplateOutput {
    /// <p>The service template detail data that's returned by Proton.</p>
    #[doc(hidden)]
    pub service_template: std::option::Option<crate::model::ServiceTemplate>,
}
impl CreateServiceTemplateOutput {
    /// <p>The service template detail data that's returned by Proton.</p>
    pub fn service_template(&self) -> std::option::Option<&crate::model::ServiceTemplate> {
        self.service_template.as_ref()
    }
}
/// See [`CreateServiceTemplateOutput`](crate::output::CreateServiceTemplateOutput).
pub mod create_service_template_output {

    /// A builder for [`CreateServiceTemplateOutput`](crate::output::CreateServiceTemplateOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) service_template: std::option::Option<crate::model::ServiceTemplate>,
    }
    impl Builder {
        /// <p>The service template detail data that's returned by Proton.</p>
        pub fn service_template(mut self, input: crate::model::ServiceTemplate) -> Self {
            self.service_template = Some(input);
            self
        }
        /// <p>The service template detail data that's returned by Proton.</p>
        pub fn set_service_template(
            mut self,
            input: std::option::Option<crate::model::ServiceTemplate>,
        ) -> Self {
            self.service_template = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateServiceTemplateOutput`](crate::output::CreateServiceTemplateOutput).
        pub fn build(self) -> crate::output::CreateServiceTemplateOutput {
            crate::output::CreateServiceTemplateOutput {
                service_template: self.service_template,
            }
        }
    }
}
impl CreateServiceTemplateOutput {
    /// Creates a new builder-style object to manufacture [`CreateServiceTemplateOutput`](crate::output::CreateServiceTemplateOutput).
    pub fn builder() -> crate::output::create_service_template_output::Builder {
        crate::output::create_service_template_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteServiceTemplateOutput {
    /// <p>The detailed data of the service template being deleted.</p>
    #[doc(hidden)]
    pub service_template: std::option::Option<crate::model::ServiceTemplate>,
}
impl DeleteServiceTemplateOutput {
    /// <p>The detailed data of the service template being deleted.</p>
    pub fn service_template(&self) -> std::option::Option<&crate::model::ServiceTemplate> {
        self.service_template.as_ref()
    }
}
/// See [`DeleteServiceTemplateOutput`](crate::output::DeleteServiceTemplateOutput).
pub mod delete_service_template_output {

    /// A builder for [`DeleteServiceTemplateOutput`](crate::output::DeleteServiceTemplateOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) service_template: std::option::Option<crate::model::ServiceTemplate>,
    }
    impl Builder {
        /// <p>The detailed data of the service template being deleted.</p>
        pub fn service_template(mut self, input: crate::model::ServiceTemplate) -> Self {
            self.service_template = Some(input);
            self
        }
        /// <p>The detailed data of the service template being deleted.</p>
        pub fn set_service_template(
            mut self,
            input: std::option::Option<crate::model::ServiceTemplate>,
        ) -> Self {
            self.service_template = input;
            self
        }
        /// Consumes the builder and constructs a [`DeleteServiceTemplateOutput`](crate::output::DeleteServiceTemplateOutput).
        pub fn build(self) -> crate::output::DeleteServiceTemplateOutput {
            crate::output::DeleteServiceTemplateOutput {
                service_template: self.service_template,
            }
        }
    }
}
impl DeleteServiceTemplateOutput {
    /// Creates a new builder-style object to manufacture [`DeleteServiceTemplateOutput`](crate::output::DeleteServiceTemplateOutput).
    pub fn builder() -> crate::output::delete_service_template_output::Builder {
        crate::output::delete_service_template_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateServiceTemplateOutput {
    /// <p>The service template detail data that's returned by Proton.</p>
    #[doc(hidden)]
    pub service_template: std::option::Option<crate::model::ServiceTemplate>,
}
impl UpdateServiceTemplateOutput {
    /// <p>The service template detail data that's returned by Proton.</p>
    pub fn service_template(&self) -> std::option::Option<&crate::model::ServiceTemplate> {
        self.service_template.as_ref()
    }
}
/// See [`UpdateServiceTemplateOutput`](crate::output::UpdateServiceTemplateOutput).
pub mod update_service_template_output {

    /// A builder for [`UpdateServiceTemplateOutput`](crate::output::UpdateServiceTemplateOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) service_template: std::option::Option<crate::model::ServiceTemplate>,
    }
    impl Builder {
        /// <p>The service template detail data that's returned by Proton.</p>
        pub fn service_template(mut self, input: crate::model::ServiceTemplate) -> Self {
            self.service_template = Some(input);
            self
        }
        /// <p>The service template detail data that's returned by Proton.</p>
        pub fn set_service_template(
            mut self,
            input: std::option::Option<crate::model::ServiceTemplate>,
        ) -> Self {
            self.service_template = input;
            self
        }
        /// Consumes the builder and constructs a [`UpdateServiceTemplateOutput`](crate::output::UpdateServiceTemplateOutput).
        pub fn build(self) -> crate::output::UpdateServiceTemplateOutput {
            crate::output::UpdateServiceTemplateOutput {
                service_template: self.service_template,
            }
        }
    }
}
impl UpdateServiceTemplateOutput {
    /// Creates a new builder-style object to manufacture [`UpdateServiceTemplateOutput`](crate::output::UpdateServiceTemplateOutput).
    pub fn builder() -> crate::output::update_service_template_output::Builder {
        crate::output::update_service_template_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetServiceTemplateOutput {
    /// <p>The detailed data of the requested service template.</p>
    #[doc(hidden)]
    pub service_template: std::option::Option<crate::model::ServiceTemplate>,
}
impl GetServiceTemplateOutput {
    /// <p>The detailed data of the requested service template.</p>
    pub fn service_template(&self) -> std::option::Option<&crate::model::ServiceTemplate> {
        self.service_template.as_ref()
    }
}
/// See [`GetServiceTemplateOutput`](crate::output::GetServiceTemplateOutput).
pub mod get_service_template_output {

    /// A builder for [`GetServiceTemplateOutput`](crate::output::GetServiceTemplateOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) service_template: std::option::Option<crate::model::ServiceTemplate>,
    }
    impl Builder {
        /// <p>The detailed data of the requested service template.</p>
        pub fn service_template(mut self, input: crate::model::ServiceTemplate) -> Self {
            self.service_template = Some(input);
            self
        }
        /// <p>The detailed data of the requested service template.</p>
        pub fn set_service_template(
            mut self,
            input: std::option::Option<crate::model::ServiceTemplate>,
        ) -> Self {
            self.service_template = input;
            self
        }
        /// Consumes the builder and constructs a [`GetServiceTemplateOutput`](crate::output::GetServiceTemplateOutput).
        pub fn build(self) -> crate::output::GetServiceTemplateOutput {
            crate::output::GetServiceTemplateOutput {
                service_template: self.service_template,
            }
        }
    }
}
impl GetServiceTemplateOutput {
    /// Creates a new builder-style object to manufacture [`GetServiceTemplateOutput`](crate::output::GetServiceTemplateOutput).
    pub fn builder() -> crate::output::get_service_template_output::Builder {
        crate::output::get_service_template_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListServicesOutput {
    /// <p>A token that indicates the location of the next service in the array of services, after the current requested list of services.</p>
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
    /// <p>An array of services with summaries of detail data.</p>
    #[doc(hidden)]
    pub services: std::option::Option<std::vec::Vec<crate::model::ServiceSummary>>,
}
impl ListServicesOutput {
    /// <p>A token that indicates the location of the next service in the array of services, after the current requested list of services.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// <p>An array of services with summaries of detail data.</p>
    pub fn services(&self) -> std::option::Option<&[crate::model::ServiceSummary]> {
        self.services.as_deref()
    }
}
/// See [`ListServicesOutput`](crate::output::ListServicesOutput).
pub mod list_services_output {

    /// A builder for [`ListServicesOutput`](crate::output::ListServicesOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) services: std::option::Option<std::vec::Vec<crate::model::ServiceSummary>>,
    }
    impl Builder {
        /// <p>A token that indicates the location of the next service in the array of services, after the current requested list of services.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>A token that indicates the location of the next service in the array of services, after the current requested list of services.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Appends an item to `services`.
        ///
        /// To override the contents of this collection use [`set_services`](Self::set_services).
        ///
        /// <p>An array of services with summaries of detail data.</p>
        pub fn services(mut self, input: crate::model::ServiceSummary) -> Self {
            let mut v = self.services.unwrap_or_default();
            v.push(input);
            self.services = Some(v);
            self
        }
        /// <p>An array of services with summaries of detail data.</p>
        pub fn set_services(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ServiceSummary>>,
        ) -> Self {
            self.services = input;
            self
        }
        /// Consumes the builder and constructs a [`ListServicesOutput`](crate::output::ListServicesOutput).
        pub fn build(self) -> crate::output::ListServicesOutput {
            crate::output::ListServicesOutput {
                next_token: self.next_token,
                services: self.services,
            }
        }
    }
}
impl ListServicesOutput {
    /// Creates a new builder-style object to manufacture [`ListServicesOutput`](crate::output::ListServicesOutput).
    pub fn builder() -> crate::output::list_services_output::Builder {
        crate::output::list_services_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateServiceOutput {
    /// <p>The service detail data that's returned by Proton.</p>
    #[doc(hidden)]
    pub service: std::option::Option<crate::model::Service>,
}
impl CreateServiceOutput {
    /// <p>The service detail data that's returned by Proton.</p>
    pub fn service(&self) -> std::option::Option<&crate::model::Service> {
        self.service.as_ref()
    }
}
/// See [`CreateServiceOutput`](crate::output::CreateServiceOutput).
pub mod create_service_output {

    /// A builder for [`CreateServiceOutput`](crate::output::CreateServiceOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) service: std::option::Option<crate::model::Service>,
    }
    impl Builder {
        /// <p>The service detail data that's returned by Proton.</p>
        pub fn service(mut self, input: crate::model::Service) -> Self {
            self.service = Some(input);
            self
        }
        /// <p>The service detail data that's returned by Proton.</p>
        pub fn set_service(mut self, input: std::option::Option<crate::model::Service>) -> Self {
            self.service = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateServiceOutput`](crate::output::CreateServiceOutput).
        pub fn build(self) -> crate::output::CreateServiceOutput {
            crate::output::CreateServiceOutput {
                service: self.service,
            }
        }
    }
}
impl CreateServiceOutput {
    /// Creates a new builder-style object to manufacture [`CreateServiceOutput`](crate::output::CreateServiceOutput).
    pub fn builder() -> crate::output::create_service_output::Builder {
        crate::output::create_service_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteServiceOutput {
    /// <p>The detailed data of the service being deleted.</p>
    #[doc(hidden)]
    pub service: std::option::Option<crate::model::Service>,
}
impl DeleteServiceOutput {
    /// <p>The detailed data of the service being deleted.</p>
    pub fn service(&self) -> std::option::Option<&crate::model::Service> {
        self.service.as_ref()
    }
}
/// See [`DeleteServiceOutput`](crate::output::DeleteServiceOutput).
pub mod delete_service_output {

    /// A builder for [`DeleteServiceOutput`](crate::output::DeleteServiceOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) service: std::option::Option<crate::model::Service>,
    }
    impl Builder {
        /// <p>The detailed data of the service being deleted.</p>
        pub fn service(mut self, input: crate::model::Service) -> Self {
            self.service = Some(input);
            self
        }
        /// <p>The detailed data of the service being deleted.</p>
        pub fn set_service(mut self, input: std::option::Option<crate::model::Service>) -> Self {
            self.service = input;
            self
        }
        /// Consumes the builder and constructs a [`DeleteServiceOutput`](crate::output::DeleteServiceOutput).
        pub fn build(self) -> crate::output::DeleteServiceOutput {
            crate::output::DeleteServiceOutput {
                service: self.service,
            }
        }
    }
}
impl DeleteServiceOutput {
    /// Creates a new builder-style object to manufacture [`DeleteServiceOutput`](crate::output::DeleteServiceOutput).
    pub fn builder() -> crate::output::delete_service_output::Builder {
        crate::output::delete_service_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateServiceOutput {
    /// <p>The service detail data that's returned by Proton.</p>
    #[doc(hidden)]
    pub service: std::option::Option<crate::model::Service>,
}
impl UpdateServiceOutput {
    /// <p>The service detail data that's returned by Proton.</p>
    pub fn service(&self) -> std::option::Option<&crate::model::Service> {
        self.service.as_ref()
    }
}
/// See [`UpdateServiceOutput`](crate::output::UpdateServiceOutput).
pub mod update_service_output {

    /// A builder for [`UpdateServiceOutput`](crate::output::UpdateServiceOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) service: std::option::Option<crate::model::Service>,
    }
    impl Builder {
        /// <p>The service detail data that's returned by Proton.</p>
        pub fn service(mut self, input: crate::model::Service) -> Self {
            self.service = Some(input);
            self
        }
        /// <p>The service detail data that's returned by Proton.</p>
        pub fn set_service(mut self, input: std::option::Option<crate::model::Service>) -> Self {
            self.service = input;
            self
        }
        /// Consumes the builder and constructs a [`UpdateServiceOutput`](crate::output::UpdateServiceOutput).
        pub fn build(self) -> crate::output::UpdateServiceOutput {
            crate::output::UpdateServiceOutput {
                service: self.service,
            }
        }
    }
}
impl UpdateServiceOutput {
    /// Creates a new builder-style object to manufacture [`UpdateServiceOutput`](crate::output::UpdateServiceOutput).
    pub fn builder() -> crate::output::update_service_output::Builder {
        crate::output::update_service_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetServiceOutput {
    /// <p>The detailed data of the requested service.</p>
    #[doc(hidden)]
    pub service: std::option::Option<crate::model::Service>,
}
impl GetServiceOutput {
    /// <p>The detailed data of the requested service.</p>
    pub fn service(&self) -> std::option::Option<&crate::model::Service> {
        self.service.as_ref()
    }
}
/// See [`GetServiceOutput`](crate::output::GetServiceOutput).
pub mod get_service_output {

    /// A builder for [`GetServiceOutput`](crate::output::GetServiceOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) service: std::option::Option<crate::model::Service>,
    }
    impl Builder {
        /// <p>The detailed data of the requested service.</p>
        pub fn service(mut self, input: crate::model::Service) -> Self {
            self.service = Some(input);
            self
        }
        /// <p>The detailed data of the requested service.</p>
        pub fn set_service(mut self, input: std::option::Option<crate::model::Service>) -> Self {
            self.service = input;
            self
        }
        /// Consumes the builder and constructs a [`GetServiceOutput`](crate::output::GetServiceOutput).
        pub fn build(self) -> crate::output::GetServiceOutput {
            crate::output::GetServiceOutput {
                service: self.service,
            }
        }
    }
}
impl GetServiceOutput {
    /// Creates a new builder-style object to manufacture [`GetServiceOutput`](crate::output::GetServiceOutput).
    pub fn builder() -> crate::output::get_service_output::Builder {
        crate::output::get_service_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateServicePipelineOutput {
    /// <p>The pipeline details that are returned by Proton.</p>
    #[doc(hidden)]
    pub pipeline: std::option::Option<crate::model::ServicePipeline>,
}
impl UpdateServicePipelineOutput {
    /// <p>The pipeline details that are returned by Proton.</p>
    pub fn pipeline(&self) -> std::option::Option<&crate::model::ServicePipeline> {
        self.pipeline.as_ref()
    }
}
/// See [`UpdateServicePipelineOutput`](crate::output::UpdateServicePipelineOutput).
pub mod update_service_pipeline_output {

    /// A builder for [`UpdateServicePipelineOutput`](crate::output::UpdateServicePipelineOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) pipeline: std::option::Option<crate::model::ServicePipeline>,
    }
    impl Builder {
        /// <p>The pipeline details that are returned by Proton.</p>
        pub fn pipeline(mut self, input: crate::model::ServicePipeline) -> Self {
            self.pipeline = Some(input);
            self
        }
        /// <p>The pipeline details that are returned by Proton.</p>
        pub fn set_pipeline(
            mut self,
            input: std::option::Option<crate::model::ServicePipeline>,
        ) -> Self {
            self.pipeline = input;
            self
        }
        /// Consumes the builder and constructs a [`UpdateServicePipelineOutput`](crate::output::UpdateServicePipelineOutput).
        pub fn build(self) -> crate::output::UpdateServicePipelineOutput {
            crate::output::UpdateServicePipelineOutput {
                pipeline: self.pipeline,
            }
        }
    }
}
impl UpdateServicePipelineOutput {
    /// Creates a new builder-style object to manufacture [`UpdateServicePipelineOutput`](crate::output::UpdateServicePipelineOutput).
    pub fn builder() -> crate::output::update_service_pipeline_output::Builder {
        crate::output::update_service_pipeline_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListServicePipelineProvisionedResourcesOutput {
    /// <p>A token that indicates the location of the next provisioned resource in the array of provisioned resources, after the current requested list of provisioned resources.</p>
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
    /// <p>An array of provisioned resources for a service and pipeline.</p>
    #[doc(hidden)]
    pub provisioned_resources:
        std::option::Option<std::vec::Vec<crate::model::ProvisionedResource>>,
}
impl ListServicePipelineProvisionedResourcesOutput {
    /// <p>A token that indicates the location of the next provisioned resource in the array of provisioned resources, after the current requested list of provisioned resources.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// <p>An array of provisioned resources for a service and pipeline.</p>
    pub fn provisioned_resources(
        &self,
    ) -> std::option::Option<&[crate::model::ProvisionedResource]> {
        self.provisioned_resources.as_deref()
    }
}
/// See [`ListServicePipelineProvisionedResourcesOutput`](crate::output::ListServicePipelineProvisionedResourcesOutput).
pub mod list_service_pipeline_provisioned_resources_output {

    /// A builder for [`ListServicePipelineProvisionedResourcesOutput`](crate::output::ListServicePipelineProvisionedResourcesOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) provisioned_resources:
            std::option::Option<std::vec::Vec<crate::model::ProvisionedResource>>,
    }
    impl Builder {
        /// <p>A token that indicates the location of the next provisioned resource in the array of provisioned resources, after the current requested list of provisioned resources.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>A token that indicates the location of the next provisioned resource in the array of provisioned resources, after the current requested list of provisioned resources.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Appends an item to `provisioned_resources`.
        ///
        /// To override the contents of this collection use [`set_provisioned_resources`](Self::set_provisioned_resources).
        ///
        /// <p>An array of provisioned resources for a service and pipeline.</p>
        pub fn provisioned_resources(mut self, input: crate::model::ProvisionedResource) -> Self {
            let mut v = self.provisioned_resources.unwrap_or_default();
            v.push(input);
            self.provisioned_resources = Some(v);
            self
        }
        /// <p>An array of provisioned resources for a service and pipeline.</p>
        pub fn set_provisioned_resources(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ProvisionedResource>>,
        ) -> Self {
            self.provisioned_resources = input;
            self
        }
        /// Consumes the builder and constructs a [`ListServicePipelineProvisionedResourcesOutput`](crate::output::ListServicePipelineProvisionedResourcesOutput).
        pub fn build(self) -> crate::output::ListServicePipelineProvisionedResourcesOutput {
            crate::output::ListServicePipelineProvisionedResourcesOutput {
                next_token: self.next_token,
                provisioned_resources: self.provisioned_resources,
            }
        }
    }
}
impl ListServicePipelineProvisionedResourcesOutput {
    /// Creates a new builder-style object to manufacture [`ListServicePipelineProvisionedResourcesOutput`](crate::output::ListServicePipelineProvisionedResourcesOutput).
    pub fn builder() -> crate::output::list_service_pipeline_provisioned_resources_output::Builder {
        crate::output::list_service_pipeline_provisioned_resources_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListServicePipelineOutputsOutput {
    /// <p>A token that indicates the location of the next output in the array of outputs, after the current requested list of outputs.</p>
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
    /// <p>An array of service pipeline Infrastructure as Code (IaC) outputs.</p>
    #[doc(hidden)]
    pub outputs: std::option::Option<std::vec::Vec<crate::model::Output>>,
}
impl ListServicePipelineOutputsOutput {
    /// <p>A token that indicates the location of the next output in the array of outputs, after the current requested list of outputs.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// <p>An array of service pipeline Infrastructure as Code (IaC) outputs.</p>
    pub fn outputs(&self) -> std::option::Option<&[crate::model::Output]> {
        self.outputs.as_deref()
    }
}
/// See [`ListServicePipelineOutputsOutput`](crate::output::ListServicePipelineOutputsOutput).
pub mod list_service_pipeline_outputs_output {

    /// A builder for [`ListServicePipelineOutputsOutput`](crate::output::ListServicePipelineOutputsOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) outputs: std::option::Option<std::vec::Vec<crate::model::Output>>,
    }
    impl Builder {
        /// <p>A token that indicates the location of the next output in the array of outputs, after the current requested list of outputs.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>A token that indicates the location of the next output in the array of outputs, after the current requested list of outputs.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Appends an item to `outputs`.
        ///
        /// To override the contents of this collection use [`set_outputs`](Self::set_outputs).
        ///
        /// <p>An array of service pipeline Infrastructure as Code (IaC) outputs.</p>
        pub fn outputs(mut self, input: crate::model::Output) -> Self {
            let mut v = self.outputs.unwrap_or_default();
            v.push(input);
            self.outputs = Some(v);
            self
        }
        /// <p>An array of service pipeline Infrastructure as Code (IaC) outputs.</p>
        pub fn set_outputs(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Output>>,
        ) -> Self {
            self.outputs = input;
            self
        }
        /// Consumes the builder and constructs a [`ListServicePipelineOutputsOutput`](crate::output::ListServicePipelineOutputsOutput).
        pub fn build(self) -> crate::output::ListServicePipelineOutputsOutput {
            crate::output::ListServicePipelineOutputsOutput {
                next_token: self.next_token,
                outputs: self.outputs,
            }
        }
    }
}
impl ListServicePipelineOutputsOutput {
    /// Creates a new builder-style object to manufacture [`ListServicePipelineOutputsOutput`](crate::output::ListServicePipelineOutputsOutput).
    pub fn builder() -> crate::output::list_service_pipeline_outputs_output::Builder {
        crate::output::list_service_pipeline_outputs_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListServiceInstancesOutput {
    /// <p>A token that indicates the location of the next service instance in the array of service instances, after the current requested list of service instances.</p>
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
    /// <p>An array of service instances with summary data.</p>
    #[doc(hidden)]
    pub service_instances: std::option::Option<std::vec::Vec<crate::model::ServiceInstanceSummary>>,
}
impl ListServiceInstancesOutput {
    /// <p>A token that indicates the location of the next service instance in the array of service instances, after the current requested list of service instances.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// <p>An array of service instances with summary data.</p>
    pub fn service_instances(
        &self,
    ) -> std::option::Option<&[crate::model::ServiceInstanceSummary]> {
        self.service_instances.as_deref()
    }
}
/// See [`ListServiceInstancesOutput`](crate::output::ListServiceInstancesOutput).
pub mod list_service_instances_output {

    /// A builder for [`ListServiceInstancesOutput`](crate::output::ListServiceInstancesOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) service_instances:
            std::option::Option<std::vec::Vec<crate::model::ServiceInstanceSummary>>,
    }
    impl Builder {
        /// <p>A token that indicates the location of the next service instance in the array of service instances, after the current requested list of service instances.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>A token that indicates the location of the next service instance in the array of service instances, after the current requested list of service instances.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Appends an item to `service_instances`.
        ///
        /// To override the contents of this collection use [`set_service_instances`](Self::set_service_instances).
        ///
        /// <p>An array of service instances with summary data.</p>
        pub fn service_instances(mut self, input: crate::model::ServiceInstanceSummary) -> Self {
            let mut v = self.service_instances.unwrap_or_default();
            v.push(input);
            self.service_instances = Some(v);
            self
        }
        /// <p>An array of service instances with summary data.</p>
        pub fn set_service_instances(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ServiceInstanceSummary>>,
        ) -> Self {
            self.service_instances = input;
            self
        }
        /// Consumes the builder and constructs a [`ListServiceInstancesOutput`](crate::output::ListServiceInstancesOutput).
        pub fn build(self) -> crate::output::ListServiceInstancesOutput {
            crate::output::ListServiceInstancesOutput {
                next_token: self.next_token,
                service_instances: self.service_instances,
            }
        }
    }
}
impl ListServiceInstancesOutput {
    /// Creates a new builder-style object to manufacture [`ListServiceInstancesOutput`](crate::output::ListServiceInstancesOutput).
    pub fn builder() -> crate::output::list_service_instances_output::Builder {
        crate::output::list_service_instances_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateServiceInstanceOutput {
    /// <p>The service instance summary data that's returned by Proton.</p>
    #[doc(hidden)]
    pub service_instance: std::option::Option<crate::model::ServiceInstance>,
}
impl UpdateServiceInstanceOutput {
    /// <p>The service instance summary data that's returned by Proton.</p>
    pub fn service_instance(&self) -> std::option::Option<&crate::model::ServiceInstance> {
        self.service_instance.as_ref()
    }
}
/// See [`UpdateServiceInstanceOutput`](crate::output::UpdateServiceInstanceOutput).
pub mod update_service_instance_output {

    /// A builder for [`UpdateServiceInstanceOutput`](crate::output::UpdateServiceInstanceOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) service_instance: std::option::Option<crate::model::ServiceInstance>,
    }
    impl Builder {
        /// <p>The service instance summary data that's returned by Proton.</p>
        pub fn service_instance(mut self, input: crate::model::ServiceInstance) -> Self {
            self.service_instance = Some(input);
            self
        }
        /// <p>The service instance summary data that's returned by Proton.</p>
        pub fn set_service_instance(
            mut self,
            input: std::option::Option<crate::model::ServiceInstance>,
        ) -> Self {
            self.service_instance = input;
            self
        }
        /// Consumes the builder and constructs a [`UpdateServiceInstanceOutput`](crate::output::UpdateServiceInstanceOutput).
        pub fn build(self) -> crate::output::UpdateServiceInstanceOutput {
            crate::output::UpdateServiceInstanceOutput {
                service_instance: self.service_instance,
            }
        }
    }
}
impl UpdateServiceInstanceOutput {
    /// Creates a new builder-style object to manufacture [`UpdateServiceInstanceOutput`](crate::output::UpdateServiceInstanceOutput).
    pub fn builder() -> crate::output::update_service_instance_output::Builder {
        crate::output::update_service_instance_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetServiceInstanceOutput {
    /// <p>The detailed data of the requested service instance.</p>
    #[doc(hidden)]
    pub service_instance: std::option::Option<crate::model::ServiceInstance>,
}
impl GetServiceInstanceOutput {
    /// <p>The detailed data of the requested service instance.</p>
    pub fn service_instance(&self) -> std::option::Option<&crate::model::ServiceInstance> {
        self.service_instance.as_ref()
    }
}
/// See [`GetServiceInstanceOutput`](crate::output::GetServiceInstanceOutput).
pub mod get_service_instance_output {

    /// A builder for [`GetServiceInstanceOutput`](crate::output::GetServiceInstanceOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) service_instance: std::option::Option<crate::model::ServiceInstance>,
    }
    impl Builder {
        /// <p>The detailed data of the requested service instance.</p>
        pub fn service_instance(mut self, input: crate::model::ServiceInstance) -> Self {
            self.service_instance = Some(input);
            self
        }
        /// <p>The detailed data of the requested service instance.</p>
        pub fn set_service_instance(
            mut self,
            input: std::option::Option<crate::model::ServiceInstance>,
        ) -> Self {
            self.service_instance = input;
            self
        }
        /// Consumes the builder and constructs a [`GetServiceInstanceOutput`](crate::output::GetServiceInstanceOutput).
        pub fn build(self) -> crate::output::GetServiceInstanceOutput {
            crate::output::GetServiceInstanceOutput {
                service_instance: self.service_instance,
            }
        }
    }
}
impl GetServiceInstanceOutput {
    /// Creates a new builder-style object to manufacture [`GetServiceInstanceOutput`](crate::output::GetServiceInstanceOutput).
    pub fn builder() -> crate::output::get_service_instance_output::Builder {
        crate::output::get_service_instance_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListServiceInstanceProvisionedResourcesOutput {
    /// <p>A token that indicates the location of the next provisioned resource in the array of provisioned resources, after the current requested list of provisioned resources.</p>
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
    /// <p>An array of provisioned resources for a service instance.</p>
    #[doc(hidden)]
    pub provisioned_resources:
        std::option::Option<std::vec::Vec<crate::model::ProvisionedResource>>,
}
impl ListServiceInstanceProvisionedResourcesOutput {
    /// <p>A token that indicates the location of the next provisioned resource in the array of provisioned resources, after the current requested list of provisioned resources.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// <p>An array of provisioned resources for a service instance.</p>
    pub fn provisioned_resources(
        &self,
    ) -> std::option::Option<&[crate::model::ProvisionedResource]> {
        self.provisioned_resources.as_deref()
    }
}
/// See [`ListServiceInstanceProvisionedResourcesOutput`](crate::output::ListServiceInstanceProvisionedResourcesOutput).
pub mod list_service_instance_provisioned_resources_output {

    /// A builder for [`ListServiceInstanceProvisionedResourcesOutput`](crate::output::ListServiceInstanceProvisionedResourcesOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) provisioned_resources:
            std::option::Option<std::vec::Vec<crate::model::ProvisionedResource>>,
    }
    impl Builder {
        /// <p>A token that indicates the location of the next provisioned resource in the array of provisioned resources, after the current requested list of provisioned resources.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>A token that indicates the location of the next provisioned resource in the array of provisioned resources, after the current requested list of provisioned resources.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Appends an item to `provisioned_resources`.
        ///
        /// To override the contents of this collection use [`set_provisioned_resources`](Self::set_provisioned_resources).
        ///
        /// <p>An array of provisioned resources for a service instance.</p>
        pub fn provisioned_resources(mut self, input: crate::model::ProvisionedResource) -> Self {
            let mut v = self.provisioned_resources.unwrap_or_default();
            v.push(input);
            self.provisioned_resources = Some(v);
            self
        }
        /// <p>An array of provisioned resources for a service instance.</p>
        pub fn set_provisioned_resources(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ProvisionedResource>>,
        ) -> Self {
            self.provisioned_resources = input;
            self
        }
        /// Consumes the builder and constructs a [`ListServiceInstanceProvisionedResourcesOutput`](crate::output::ListServiceInstanceProvisionedResourcesOutput).
        pub fn build(self) -> crate::output::ListServiceInstanceProvisionedResourcesOutput {
            crate::output::ListServiceInstanceProvisionedResourcesOutput {
                next_token: self.next_token,
                provisioned_resources: self.provisioned_resources,
            }
        }
    }
}
impl ListServiceInstanceProvisionedResourcesOutput {
    /// Creates a new builder-style object to manufacture [`ListServiceInstanceProvisionedResourcesOutput`](crate::output::ListServiceInstanceProvisionedResourcesOutput).
    pub fn builder() -> crate::output::list_service_instance_provisioned_resources_output::Builder {
        crate::output::list_service_instance_provisioned_resources_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListServiceInstanceOutputsOutput {
    /// <p>A token that indicates the location of the next output in the array of outputs, after the current requested list of outputs.</p>
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
    /// <p>An array of service instance Infrastructure as Code (IaC) outputs.</p>
    #[doc(hidden)]
    pub outputs: std::option::Option<std::vec::Vec<crate::model::Output>>,
}
impl ListServiceInstanceOutputsOutput {
    /// <p>A token that indicates the location of the next output in the array of outputs, after the current requested list of outputs.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// <p>An array of service instance Infrastructure as Code (IaC) outputs.</p>
    pub fn outputs(&self) -> std::option::Option<&[crate::model::Output]> {
        self.outputs.as_deref()
    }
}
/// See [`ListServiceInstanceOutputsOutput`](crate::output::ListServiceInstanceOutputsOutput).
pub mod list_service_instance_outputs_output {

    /// A builder for [`ListServiceInstanceOutputsOutput`](crate::output::ListServiceInstanceOutputsOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) outputs: std::option::Option<std::vec::Vec<crate::model::Output>>,
    }
    impl Builder {
        /// <p>A token that indicates the location of the next output in the array of outputs, after the current requested list of outputs.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>A token that indicates the location of the next output in the array of outputs, after the current requested list of outputs.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Appends an item to `outputs`.
        ///
        /// To override the contents of this collection use [`set_outputs`](Self::set_outputs).
        ///
        /// <p>An array of service instance Infrastructure as Code (IaC) outputs.</p>
        pub fn outputs(mut self, input: crate::model::Output) -> Self {
            let mut v = self.outputs.unwrap_or_default();
            v.push(input);
            self.outputs = Some(v);
            self
        }
        /// <p>An array of service instance Infrastructure as Code (IaC) outputs.</p>
        pub fn set_outputs(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Output>>,
        ) -> Self {
            self.outputs = input;
            self
        }
        /// Consumes the builder and constructs a [`ListServiceInstanceOutputsOutput`](crate::output::ListServiceInstanceOutputsOutput).
        pub fn build(self) -> crate::output::ListServiceInstanceOutputsOutput {
            crate::output::ListServiceInstanceOutputsOutput {
                next_token: self.next_token,
                outputs: self.outputs,
            }
        }
    }
}
impl ListServiceInstanceOutputsOutput {
    /// Creates a new builder-style object to manufacture [`ListServiceInstanceOutputsOutput`](crate::output::ListServiceInstanceOutputsOutput).
    pub fn builder() -> crate::output::list_service_instance_outputs_output::Builder {
        crate::output::list_service_instance_outputs_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListRepositoriesOutput {
    /// <p>A token that indicates the location of the next repository in the array of repositories, after the current requested list of repositories. </p>
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
    /// <p>An array of repository links.</p>
    #[doc(hidden)]
    pub repositories: std::option::Option<std::vec::Vec<crate::model::RepositorySummary>>,
}
impl ListRepositoriesOutput {
    /// <p>A token that indicates the location of the next repository in the array of repositories, after the current requested list of repositories. </p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// <p>An array of repository links.</p>
    pub fn repositories(&self) -> std::option::Option<&[crate::model::RepositorySummary]> {
        self.repositories.as_deref()
    }
}
/// See [`ListRepositoriesOutput`](crate::output::ListRepositoriesOutput).
pub mod list_repositories_output {

    /// A builder for [`ListRepositoriesOutput`](crate::output::ListRepositoriesOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) repositories:
            std::option::Option<std::vec::Vec<crate::model::RepositorySummary>>,
    }
    impl Builder {
        /// <p>A token that indicates the location of the next repository in the array of repositories, after the current requested list of repositories. </p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>A token that indicates the location of the next repository in the array of repositories, after the current requested list of repositories. </p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Appends an item to `repositories`.
        ///
        /// To override the contents of this collection use [`set_repositories`](Self::set_repositories).
        ///
        /// <p>An array of repository links.</p>
        pub fn repositories(mut self, input: crate::model::RepositorySummary) -> Self {
            let mut v = self.repositories.unwrap_or_default();
            v.push(input);
            self.repositories = Some(v);
            self
        }
        /// <p>An array of repository links.</p>
        pub fn set_repositories(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::RepositorySummary>>,
        ) -> Self {
            self.repositories = input;
            self
        }
        /// Consumes the builder and constructs a [`ListRepositoriesOutput`](crate::output::ListRepositoriesOutput).
        pub fn build(self) -> crate::output::ListRepositoriesOutput {
            crate::output::ListRepositoriesOutput {
                next_token: self.next_token,
                repositories: self.repositories,
            }
        }
    }
}
impl ListRepositoriesOutput {
    /// Creates a new builder-style object to manufacture [`ListRepositoriesOutput`](crate::output::ListRepositoriesOutput).
    pub fn builder() -> crate::output::list_repositories_output::Builder {
        crate::output::list_repositories_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateRepositoryOutput {
    /// <p>The repository link's detail data that's returned by Proton.</p>
    #[doc(hidden)]
    pub repository: std::option::Option<crate::model::Repository>,
}
impl CreateRepositoryOutput {
    /// <p>The repository link's detail data that's returned by Proton.</p>
    pub fn repository(&self) -> std::option::Option<&crate::model::Repository> {
        self.repository.as_ref()
    }
}
/// See [`CreateRepositoryOutput`](crate::output::CreateRepositoryOutput).
pub mod create_repository_output {

    /// A builder for [`CreateRepositoryOutput`](crate::output::CreateRepositoryOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) repository: std::option::Option<crate::model::Repository>,
    }
    impl Builder {
        /// <p>The repository link's detail data that's returned by Proton.</p>
        pub fn repository(mut self, input: crate::model::Repository) -> Self {
            self.repository = Some(input);
            self
        }
        /// <p>The repository link's detail data that's returned by Proton.</p>
        pub fn set_repository(
            mut self,
            input: std::option::Option<crate::model::Repository>,
        ) -> Self {
            self.repository = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateRepositoryOutput`](crate::output::CreateRepositoryOutput).
        pub fn build(self) -> crate::output::CreateRepositoryOutput {
            crate::output::CreateRepositoryOutput {
                repository: self.repository,
            }
        }
    }
}
impl CreateRepositoryOutput {
    /// Creates a new builder-style object to manufacture [`CreateRepositoryOutput`](crate::output::CreateRepositoryOutput).
    pub fn builder() -> crate::output::create_repository_output::Builder {
        crate::output::create_repository_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteRepositoryOutput {
    /// <p>The deleted repository link's detail data that's returned by Proton.</p>
    #[doc(hidden)]
    pub repository: std::option::Option<crate::model::Repository>,
}
impl DeleteRepositoryOutput {
    /// <p>The deleted repository link's detail data that's returned by Proton.</p>
    pub fn repository(&self) -> std::option::Option<&crate::model::Repository> {
        self.repository.as_ref()
    }
}
/// See [`DeleteRepositoryOutput`](crate::output::DeleteRepositoryOutput).
pub mod delete_repository_output {

    /// A builder for [`DeleteRepositoryOutput`](crate::output::DeleteRepositoryOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) repository: std::option::Option<crate::model::Repository>,
    }
    impl Builder {
        /// <p>The deleted repository link's detail data that's returned by Proton.</p>
        pub fn repository(mut self, input: crate::model::Repository) -> Self {
            self.repository = Some(input);
            self
        }
        /// <p>The deleted repository link's detail data that's returned by Proton.</p>
        pub fn set_repository(
            mut self,
            input: std::option::Option<crate::model::Repository>,
        ) -> Self {
            self.repository = input;
            self
        }
        /// Consumes the builder and constructs a [`DeleteRepositoryOutput`](crate::output::DeleteRepositoryOutput).
        pub fn build(self) -> crate::output::DeleteRepositoryOutput {
            crate::output::DeleteRepositoryOutput {
                repository: self.repository,
            }
        }
    }
}
impl DeleteRepositoryOutput {
    /// Creates a new builder-style object to manufacture [`DeleteRepositoryOutput`](crate::output::DeleteRepositoryOutput).
    pub fn builder() -> crate::output::delete_repository_output::Builder {
        crate::output::delete_repository_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetRepositoryOutput {
    /// <p>The repository link's detail data that's returned by Proton.</p>
    #[doc(hidden)]
    pub repository: std::option::Option<crate::model::Repository>,
}
impl GetRepositoryOutput {
    /// <p>The repository link's detail data that's returned by Proton.</p>
    pub fn repository(&self) -> std::option::Option<&crate::model::Repository> {
        self.repository.as_ref()
    }
}
/// See [`GetRepositoryOutput`](crate::output::GetRepositoryOutput).
pub mod get_repository_output {

    /// A builder for [`GetRepositoryOutput`](crate::output::GetRepositoryOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) repository: std::option::Option<crate::model::Repository>,
    }
    impl Builder {
        /// <p>The repository link's detail data that's returned by Proton.</p>
        pub fn repository(mut self, input: crate::model::Repository) -> Self {
            self.repository = Some(input);
            self
        }
        /// <p>The repository link's detail data that's returned by Proton.</p>
        pub fn set_repository(
            mut self,
            input: std::option::Option<crate::model::Repository>,
        ) -> Self {
            self.repository = input;
            self
        }
        /// Consumes the builder and constructs a [`GetRepositoryOutput`](crate::output::GetRepositoryOutput).
        pub fn build(self) -> crate::output::GetRepositoryOutput {
            crate::output::GetRepositoryOutput {
                repository: self.repository,
            }
        }
    }
}
impl GetRepositoryOutput {
    /// Creates a new builder-style object to manufacture [`GetRepositoryOutput`](crate::output::GetRepositoryOutput).
    pub fn builder() -> crate::output::get_repository_output::Builder {
        crate::output::get_repository_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListEnvironmentTemplateVersionsOutput {
    /// <p>A token that indicates the location of the next major or minor version in the array of major or minor versions of an environment template, after the list of major or minor versions that was previously requested.</p>
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
    /// <p>An array of major or minor versions of an environment template detail data.</p>
    #[doc(hidden)]
    pub template_versions:
        std::option::Option<std::vec::Vec<crate::model::EnvironmentTemplateVersionSummary>>,
}
impl ListEnvironmentTemplateVersionsOutput {
    /// <p>A token that indicates the location of the next major or minor version in the array of major or minor versions of an environment template, after the list of major or minor versions that was previously requested.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// <p>An array of major or minor versions of an environment template detail data.</p>
    pub fn template_versions(
        &self,
    ) -> std::option::Option<&[crate::model::EnvironmentTemplateVersionSummary]> {
        self.template_versions.as_deref()
    }
}
/// See [`ListEnvironmentTemplateVersionsOutput`](crate::output::ListEnvironmentTemplateVersionsOutput).
pub mod list_environment_template_versions_output {

    /// A builder for [`ListEnvironmentTemplateVersionsOutput`](crate::output::ListEnvironmentTemplateVersionsOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) template_versions:
            std::option::Option<std::vec::Vec<crate::model::EnvironmentTemplateVersionSummary>>,
    }
    impl Builder {
        /// <p>A token that indicates the location of the next major or minor version in the array of major or minor versions of an environment template, after the list of major or minor versions that was previously requested.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>A token that indicates the location of the next major or minor version in the array of major or minor versions of an environment template, after the list of major or minor versions that was previously requested.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Appends an item to `template_versions`.
        ///
        /// To override the contents of this collection use [`set_template_versions`](Self::set_template_versions).
        ///
        /// <p>An array of major or minor versions of an environment template detail data.</p>
        pub fn template_versions(
            mut self,
            input: crate::model::EnvironmentTemplateVersionSummary,
        ) -> Self {
            let mut v = self.template_versions.unwrap_or_default();
            v.push(input);
            self.template_versions = Some(v);
            self
        }
        /// <p>An array of major or minor versions of an environment template detail data.</p>
        pub fn set_template_versions(
            mut self,
            input: std::option::Option<
                std::vec::Vec<crate::model::EnvironmentTemplateVersionSummary>,
            >,
        ) -> Self {
            self.template_versions = input;
            self
        }
        /// Consumes the builder and constructs a [`ListEnvironmentTemplateVersionsOutput`](crate::output::ListEnvironmentTemplateVersionsOutput).
        pub fn build(self) -> crate::output::ListEnvironmentTemplateVersionsOutput {
            crate::output::ListEnvironmentTemplateVersionsOutput {
                next_token: self.next_token,
                template_versions: self.template_versions,
            }
        }
    }
}
impl ListEnvironmentTemplateVersionsOutput {
    /// Creates a new builder-style object to manufacture [`ListEnvironmentTemplateVersionsOutput`](crate::output::ListEnvironmentTemplateVersionsOutput).
    pub fn builder() -> crate::output::list_environment_template_versions_output::Builder {
        crate::output::list_environment_template_versions_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateEnvironmentTemplateVersionOutput {
    /// <p>The environment template detail data that's returned by Proton.</p>
    #[doc(hidden)]
    pub environment_template_version: std::option::Option<crate::model::EnvironmentTemplateVersion>,
}
impl CreateEnvironmentTemplateVersionOutput {
    /// <p>The environment template detail data that's returned by Proton.</p>
    pub fn environment_template_version(
        &self,
    ) -> std::option::Option<&crate::model::EnvironmentTemplateVersion> {
        self.environment_template_version.as_ref()
    }
}
/// See [`CreateEnvironmentTemplateVersionOutput`](crate::output::CreateEnvironmentTemplateVersionOutput).
pub mod create_environment_template_version_output {

    /// A builder for [`CreateEnvironmentTemplateVersionOutput`](crate::output::CreateEnvironmentTemplateVersionOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) environment_template_version:
            std::option::Option<crate::model::EnvironmentTemplateVersion>,
    }
    impl Builder {
        /// <p>The environment template detail data that's returned by Proton.</p>
        pub fn environment_template_version(
            mut self,
            input: crate::model::EnvironmentTemplateVersion,
        ) -> Self {
            self.environment_template_version = Some(input);
            self
        }
        /// <p>The environment template detail data that's returned by Proton.</p>
        pub fn set_environment_template_version(
            mut self,
            input: std::option::Option<crate::model::EnvironmentTemplateVersion>,
        ) -> Self {
            self.environment_template_version = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateEnvironmentTemplateVersionOutput`](crate::output::CreateEnvironmentTemplateVersionOutput).
        pub fn build(self) -> crate::output::CreateEnvironmentTemplateVersionOutput {
            crate::output::CreateEnvironmentTemplateVersionOutput {
                environment_template_version: self.environment_template_version,
            }
        }
    }
}
impl CreateEnvironmentTemplateVersionOutput {
    /// Creates a new builder-style object to manufacture [`CreateEnvironmentTemplateVersionOutput`](crate::output::CreateEnvironmentTemplateVersionOutput).
    pub fn builder() -> crate::output::create_environment_template_version_output::Builder {
        crate::output::create_environment_template_version_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteEnvironmentTemplateVersionOutput {
    /// <p>The detailed data of the environment template version being deleted.</p>
    #[doc(hidden)]
    pub environment_template_version: std::option::Option<crate::model::EnvironmentTemplateVersion>,
}
impl DeleteEnvironmentTemplateVersionOutput {
    /// <p>The detailed data of the environment template version being deleted.</p>
    pub fn environment_template_version(
        &self,
    ) -> std::option::Option<&crate::model::EnvironmentTemplateVersion> {
        self.environment_template_version.as_ref()
    }
}
/// See [`DeleteEnvironmentTemplateVersionOutput`](crate::output::DeleteEnvironmentTemplateVersionOutput).
pub mod delete_environment_template_version_output {

    /// A builder for [`DeleteEnvironmentTemplateVersionOutput`](crate::output::DeleteEnvironmentTemplateVersionOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) environment_template_version:
            std::option::Option<crate::model::EnvironmentTemplateVersion>,
    }
    impl Builder {
        /// <p>The detailed data of the environment template version being deleted.</p>
        pub fn environment_template_version(
            mut self,
            input: crate::model::EnvironmentTemplateVersion,
        ) -> Self {
            self.environment_template_version = Some(input);
            self
        }
        /// <p>The detailed data of the environment template version being deleted.</p>
        pub fn set_environment_template_version(
            mut self,
            input: std::option::Option<crate::model::EnvironmentTemplateVersion>,
        ) -> Self {
            self.environment_template_version = input;
            self
        }
        /// Consumes the builder and constructs a [`DeleteEnvironmentTemplateVersionOutput`](crate::output::DeleteEnvironmentTemplateVersionOutput).
        pub fn build(self) -> crate::output::DeleteEnvironmentTemplateVersionOutput {
            crate::output::DeleteEnvironmentTemplateVersionOutput {
                environment_template_version: self.environment_template_version,
            }
        }
    }
}
impl DeleteEnvironmentTemplateVersionOutput {
    /// Creates a new builder-style object to manufacture [`DeleteEnvironmentTemplateVersionOutput`](crate::output::DeleteEnvironmentTemplateVersionOutput).
    pub fn builder() -> crate::output::delete_environment_template_version_output::Builder {
        crate::output::delete_environment_template_version_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateEnvironmentTemplateVersionOutput {
    /// <p>The environment template version detail data that's returned by Proton.</p>
    #[doc(hidden)]
    pub environment_template_version: std::option::Option<crate::model::EnvironmentTemplateVersion>,
}
impl UpdateEnvironmentTemplateVersionOutput {
    /// <p>The environment template version detail data that's returned by Proton.</p>
    pub fn environment_template_version(
        &self,
    ) -> std::option::Option<&crate::model::EnvironmentTemplateVersion> {
        self.environment_template_version.as_ref()
    }
}
/// See [`UpdateEnvironmentTemplateVersionOutput`](crate::output::UpdateEnvironmentTemplateVersionOutput).
pub mod update_environment_template_version_output {

    /// A builder for [`UpdateEnvironmentTemplateVersionOutput`](crate::output::UpdateEnvironmentTemplateVersionOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) environment_template_version:
            std::option::Option<crate::model::EnvironmentTemplateVersion>,
    }
    impl Builder {
        /// <p>The environment template version detail data that's returned by Proton.</p>
        pub fn environment_template_version(
            mut self,
            input: crate::model::EnvironmentTemplateVersion,
        ) -> Self {
            self.environment_template_version = Some(input);
            self
        }
        /// <p>The environment template version detail data that's returned by Proton.</p>
        pub fn set_environment_template_version(
            mut self,
            input: std::option::Option<crate::model::EnvironmentTemplateVersion>,
        ) -> Self {
            self.environment_template_version = input;
            self
        }
        /// Consumes the builder and constructs a [`UpdateEnvironmentTemplateVersionOutput`](crate::output::UpdateEnvironmentTemplateVersionOutput).
        pub fn build(self) -> crate::output::UpdateEnvironmentTemplateVersionOutput {
            crate::output::UpdateEnvironmentTemplateVersionOutput {
                environment_template_version: self.environment_template_version,
            }
        }
    }
}
impl UpdateEnvironmentTemplateVersionOutput {
    /// Creates a new builder-style object to manufacture [`UpdateEnvironmentTemplateVersionOutput`](crate::output::UpdateEnvironmentTemplateVersionOutput).
    pub fn builder() -> crate::output::update_environment_template_version_output::Builder {
        crate::output::update_environment_template_version_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetEnvironmentTemplateVersionOutput {
    /// <p>The detailed data of the requested environment template version.</p>
    #[doc(hidden)]
    pub environment_template_version: std::option::Option<crate::model::EnvironmentTemplateVersion>,
}
impl GetEnvironmentTemplateVersionOutput {
    /// <p>The detailed data of the requested environment template version.</p>
    pub fn environment_template_version(
        &self,
    ) -> std::option::Option<&crate::model::EnvironmentTemplateVersion> {
        self.environment_template_version.as_ref()
    }
}
/// See [`GetEnvironmentTemplateVersionOutput`](crate::output::GetEnvironmentTemplateVersionOutput).
pub mod get_environment_template_version_output {

    /// A builder for [`GetEnvironmentTemplateVersionOutput`](crate::output::GetEnvironmentTemplateVersionOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) environment_template_version:
            std::option::Option<crate::model::EnvironmentTemplateVersion>,
    }
    impl Builder {
        /// <p>The detailed data of the requested environment template version.</p>
        pub fn environment_template_version(
            mut self,
            input: crate::model::EnvironmentTemplateVersion,
        ) -> Self {
            self.environment_template_version = Some(input);
            self
        }
        /// <p>The detailed data of the requested environment template version.</p>
        pub fn set_environment_template_version(
            mut self,
            input: std::option::Option<crate::model::EnvironmentTemplateVersion>,
        ) -> Self {
            self.environment_template_version = input;
            self
        }
        /// Consumes the builder and constructs a [`GetEnvironmentTemplateVersionOutput`](crate::output::GetEnvironmentTemplateVersionOutput).
        pub fn build(self) -> crate::output::GetEnvironmentTemplateVersionOutput {
            crate::output::GetEnvironmentTemplateVersionOutput {
                environment_template_version: self.environment_template_version,
            }
        }
    }
}
impl GetEnvironmentTemplateVersionOutput {
    /// Creates a new builder-style object to manufacture [`GetEnvironmentTemplateVersionOutput`](crate::output::GetEnvironmentTemplateVersionOutput).
    pub fn builder() -> crate::output::get_environment_template_version_output::Builder {
        crate::output::get_environment_template_version_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListEnvironmentTemplatesOutput {
    /// <p>A token that indicates the location of the next environment template in the array of environment templates, after the current requested list of environment templates.</p>
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
    /// <p>An array of environment templates with detail data.</p>
    #[doc(hidden)]
    pub templates: std::option::Option<std::vec::Vec<crate::model::EnvironmentTemplateSummary>>,
}
impl ListEnvironmentTemplatesOutput {
    /// <p>A token that indicates the location of the next environment template in the array of environment templates, after the current requested list of environment templates.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// <p>An array of environment templates with detail data.</p>
    pub fn templates(&self) -> std::option::Option<&[crate::model::EnvironmentTemplateSummary]> {
        self.templates.as_deref()
    }
}
/// See [`ListEnvironmentTemplatesOutput`](crate::output::ListEnvironmentTemplatesOutput).
pub mod list_environment_templates_output {

    /// A builder for [`ListEnvironmentTemplatesOutput`](crate::output::ListEnvironmentTemplatesOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) templates:
            std::option::Option<std::vec::Vec<crate::model::EnvironmentTemplateSummary>>,
    }
    impl Builder {
        /// <p>A token that indicates the location of the next environment template in the array of environment templates, after the current requested list of environment templates.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>A token that indicates the location of the next environment template in the array of environment templates, after the current requested list of environment templates.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Appends an item to `templates`.
        ///
        /// To override the contents of this collection use [`set_templates`](Self::set_templates).
        ///
        /// <p>An array of environment templates with detail data.</p>
        pub fn templates(mut self, input: crate::model::EnvironmentTemplateSummary) -> Self {
            let mut v = self.templates.unwrap_or_default();
            v.push(input);
            self.templates = Some(v);
            self
        }
        /// <p>An array of environment templates with detail data.</p>
        pub fn set_templates(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::EnvironmentTemplateSummary>>,
        ) -> Self {
            self.templates = input;
            self
        }
        /// Consumes the builder and constructs a [`ListEnvironmentTemplatesOutput`](crate::output::ListEnvironmentTemplatesOutput).
        pub fn build(self) -> crate::output::ListEnvironmentTemplatesOutput {
            crate::output::ListEnvironmentTemplatesOutput {
                next_token: self.next_token,
                templates: self.templates,
            }
        }
    }
}
impl ListEnvironmentTemplatesOutput {
    /// Creates a new builder-style object to manufacture [`ListEnvironmentTemplatesOutput`](crate::output::ListEnvironmentTemplatesOutput).
    pub fn builder() -> crate::output::list_environment_templates_output::Builder {
        crate::output::list_environment_templates_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateEnvironmentTemplateOutput {
    /// <p>The environment template detail data that's returned by Proton.</p>
    #[doc(hidden)]
    pub environment_template: std::option::Option<crate::model::EnvironmentTemplate>,
}
impl CreateEnvironmentTemplateOutput {
    /// <p>The environment template detail data that's returned by Proton.</p>
    pub fn environment_template(&self) -> std::option::Option<&crate::model::EnvironmentTemplate> {
        self.environment_template.as_ref()
    }
}
/// See [`CreateEnvironmentTemplateOutput`](crate::output::CreateEnvironmentTemplateOutput).
pub mod create_environment_template_output {

    /// A builder for [`CreateEnvironmentTemplateOutput`](crate::output::CreateEnvironmentTemplateOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) environment_template: std::option::Option<crate::model::EnvironmentTemplate>,
    }
    impl Builder {
        /// <p>The environment template detail data that's returned by Proton.</p>
        pub fn environment_template(mut self, input: crate::model::EnvironmentTemplate) -> Self {
            self.environment_template = Some(input);
            self
        }
        /// <p>The environment template detail data that's returned by Proton.</p>
        pub fn set_environment_template(
            mut self,
            input: std::option::Option<crate::model::EnvironmentTemplate>,
        ) -> Self {
            self.environment_template = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateEnvironmentTemplateOutput`](crate::output::CreateEnvironmentTemplateOutput).
        pub fn build(self) -> crate::output::CreateEnvironmentTemplateOutput {
            crate::output::CreateEnvironmentTemplateOutput {
                environment_template: self.environment_template,
            }
        }
    }
}
impl CreateEnvironmentTemplateOutput {
    /// Creates a new builder-style object to manufacture [`CreateEnvironmentTemplateOutput`](crate::output::CreateEnvironmentTemplateOutput).
    pub fn builder() -> crate::output::create_environment_template_output::Builder {
        crate::output::create_environment_template_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteEnvironmentTemplateOutput {
    /// <p>The detailed data of the environment template being deleted.</p>
    #[doc(hidden)]
    pub environment_template: std::option::Option<crate::model::EnvironmentTemplate>,
}
impl DeleteEnvironmentTemplateOutput {
    /// <p>The detailed data of the environment template being deleted.</p>
    pub fn environment_template(&self) -> std::option::Option<&crate::model::EnvironmentTemplate> {
        self.environment_template.as_ref()
    }
}
/// See [`DeleteEnvironmentTemplateOutput`](crate::output::DeleteEnvironmentTemplateOutput).
pub mod delete_environment_template_output {

    /// A builder for [`DeleteEnvironmentTemplateOutput`](crate::output::DeleteEnvironmentTemplateOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) environment_template: std::option::Option<crate::model::EnvironmentTemplate>,
    }
    impl Builder {
        /// <p>The detailed data of the environment template being deleted.</p>
        pub fn environment_template(mut self, input: crate::model::EnvironmentTemplate) -> Self {
            self.environment_template = Some(input);
            self
        }
        /// <p>The detailed data of the environment template being deleted.</p>
        pub fn set_environment_template(
            mut self,
            input: std::option::Option<crate::model::EnvironmentTemplate>,
        ) -> Self {
            self.environment_template = input;
            self
        }
        /// Consumes the builder and constructs a [`DeleteEnvironmentTemplateOutput`](crate::output::DeleteEnvironmentTemplateOutput).
        pub fn build(self) -> crate::output::DeleteEnvironmentTemplateOutput {
            crate::output::DeleteEnvironmentTemplateOutput {
                environment_template: self.environment_template,
            }
        }
    }
}
impl DeleteEnvironmentTemplateOutput {
    /// Creates a new builder-style object to manufacture [`DeleteEnvironmentTemplateOutput`](crate::output::DeleteEnvironmentTemplateOutput).
    pub fn builder() -> crate::output::delete_environment_template_output::Builder {
        crate::output::delete_environment_template_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateEnvironmentTemplateOutput {
    /// <p>The environment template detail data that's returned by Proton.</p>
    #[doc(hidden)]
    pub environment_template: std::option::Option<crate::model::EnvironmentTemplate>,
}
impl UpdateEnvironmentTemplateOutput {
    /// <p>The environment template detail data that's returned by Proton.</p>
    pub fn environment_template(&self) -> std::option::Option<&crate::model::EnvironmentTemplate> {
        self.environment_template.as_ref()
    }
}
/// See [`UpdateEnvironmentTemplateOutput`](crate::output::UpdateEnvironmentTemplateOutput).
pub mod update_environment_template_output {

    /// A builder for [`UpdateEnvironmentTemplateOutput`](crate::output::UpdateEnvironmentTemplateOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) environment_template: std::option::Option<crate::model::EnvironmentTemplate>,
    }
    impl Builder {
        /// <p>The environment template detail data that's returned by Proton.</p>
        pub fn environment_template(mut self, input: crate::model::EnvironmentTemplate) -> Self {
            self.environment_template = Some(input);
            self
        }
        /// <p>The environment template detail data that's returned by Proton.</p>
        pub fn set_environment_template(
            mut self,
            input: std::option::Option<crate::model::EnvironmentTemplate>,
        ) -> Self {
            self.environment_template = input;
            self
        }
        /// Consumes the builder and constructs a [`UpdateEnvironmentTemplateOutput`](crate::output::UpdateEnvironmentTemplateOutput).
        pub fn build(self) -> crate::output::UpdateEnvironmentTemplateOutput {
            crate::output::UpdateEnvironmentTemplateOutput {
                environment_template: self.environment_template,
            }
        }
    }
}
impl UpdateEnvironmentTemplateOutput {
    /// Creates a new builder-style object to manufacture [`UpdateEnvironmentTemplateOutput`](crate::output::UpdateEnvironmentTemplateOutput).
    pub fn builder() -> crate::output::update_environment_template_output::Builder {
        crate::output::update_environment_template_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetEnvironmentTemplateOutput {
    /// <p>The detailed data of the requested environment template.</p>
    #[doc(hidden)]
    pub environment_template: std::option::Option<crate::model::EnvironmentTemplate>,
}
impl GetEnvironmentTemplateOutput {
    /// <p>The detailed data of the requested environment template.</p>
    pub fn environment_template(&self) -> std::option::Option<&crate::model::EnvironmentTemplate> {
        self.environment_template.as_ref()
    }
}
/// See [`GetEnvironmentTemplateOutput`](crate::output::GetEnvironmentTemplateOutput).
pub mod get_environment_template_output {

    /// A builder for [`GetEnvironmentTemplateOutput`](crate::output::GetEnvironmentTemplateOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) environment_template: std::option::Option<crate::model::EnvironmentTemplate>,
    }
    impl Builder {
        /// <p>The detailed data of the requested environment template.</p>
        pub fn environment_template(mut self, input: crate::model::EnvironmentTemplate) -> Self {
            self.environment_template = Some(input);
            self
        }
        /// <p>The detailed data of the requested environment template.</p>
        pub fn set_environment_template(
            mut self,
            input: std::option::Option<crate::model::EnvironmentTemplate>,
        ) -> Self {
            self.environment_template = input;
            self
        }
        /// Consumes the builder and constructs a [`GetEnvironmentTemplateOutput`](crate::output::GetEnvironmentTemplateOutput).
        pub fn build(self) -> crate::output::GetEnvironmentTemplateOutput {
            crate::output::GetEnvironmentTemplateOutput {
                environment_template: self.environment_template,
            }
        }
    }
}
impl GetEnvironmentTemplateOutput {
    /// Creates a new builder-style object to manufacture [`GetEnvironmentTemplateOutput`](crate::output::GetEnvironmentTemplateOutput).
    pub fn builder() -> crate::output::get_environment_template_output::Builder {
        crate::output::get_environment_template_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListEnvironmentsOutput {
    /// <p>A token that indicates the location of the next environment in the array of environments, after the current requested list of environments.</p>
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
    /// <p>An array of environment detail data summaries.</p>
    #[doc(hidden)]
    pub environments: std::option::Option<std::vec::Vec<crate::model::EnvironmentSummary>>,
}
impl ListEnvironmentsOutput {
    /// <p>A token that indicates the location of the next environment in the array of environments, after the current requested list of environments.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// <p>An array of environment detail data summaries.</p>
    pub fn environments(&self) -> std::option::Option<&[crate::model::EnvironmentSummary]> {
        self.environments.as_deref()
    }
}
/// See [`ListEnvironmentsOutput`](crate::output::ListEnvironmentsOutput).
pub mod list_environments_output {

    /// A builder for [`ListEnvironmentsOutput`](crate::output::ListEnvironmentsOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) environments:
            std::option::Option<std::vec::Vec<crate::model::EnvironmentSummary>>,
    }
    impl Builder {
        /// <p>A token that indicates the location of the next environment in the array of environments, after the current requested list of environments.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>A token that indicates the location of the next environment in the array of environments, after the current requested list of environments.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Appends an item to `environments`.
        ///
        /// To override the contents of this collection use [`set_environments`](Self::set_environments).
        ///
        /// <p>An array of environment detail data summaries.</p>
        pub fn environments(mut self, input: crate::model::EnvironmentSummary) -> Self {
            let mut v = self.environments.unwrap_or_default();
            v.push(input);
            self.environments = Some(v);
            self
        }
        /// <p>An array of environment detail data summaries.</p>
        pub fn set_environments(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::EnvironmentSummary>>,
        ) -> Self {
            self.environments = input;
            self
        }
        /// Consumes the builder and constructs a [`ListEnvironmentsOutput`](crate::output::ListEnvironmentsOutput).
        pub fn build(self) -> crate::output::ListEnvironmentsOutput {
            crate::output::ListEnvironmentsOutput {
                next_token: self.next_token,
                environments: self.environments,
            }
        }
    }
}
impl ListEnvironmentsOutput {
    /// Creates a new builder-style object to manufacture [`ListEnvironmentsOutput`](crate::output::ListEnvironmentsOutput).
    pub fn builder() -> crate::output::list_environments_output::Builder {
        crate::output::list_environments_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateEnvironmentOutput {
    /// <p>The environment detail data that's returned by Proton.</p>
    #[doc(hidden)]
    pub environment: std::option::Option<crate::model::Environment>,
}
impl CreateEnvironmentOutput {
    /// <p>The environment detail data that's returned by Proton.</p>
    pub fn environment(&self) -> std::option::Option<&crate::model::Environment> {
        self.environment.as_ref()
    }
}
/// See [`CreateEnvironmentOutput`](crate::output::CreateEnvironmentOutput).
pub mod create_environment_output {

    /// A builder for [`CreateEnvironmentOutput`](crate::output::CreateEnvironmentOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) environment: std::option::Option<crate::model::Environment>,
    }
    impl Builder {
        /// <p>The environment detail data that's returned by Proton.</p>
        pub fn environment(mut self, input: crate::model::Environment) -> Self {
            self.environment = Some(input);
            self
        }
        /// <p>The environment detail data that's returned by Proton.</p>
        pub fn set_environment(
            mut self,
            input: std::option::Option<crate::model::Environment>,
        ) -> Self {
            self.environment = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateEnvironmentOutput`](crate::output::CreateEnvironmentOutput).
        pub fn build(self) -> crate::output::CreateEnvironmentOutput {
            crate::output::CreateEnvironmentOutput {
                environment: self.environment,
            }
        }
    }
}
impl CreateEnvironmentOutput {
    /// Creates a new builder-style object to manufacture [`CreateEnvironmentOutput`](crate::output::CreateEnvironmentOutput).
    pub fn builder() -> crate::output::create_environment_output::Builder {
        crate::output::create_environment_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteEnvironmentOutput {
    /// <p>The detailed data of the environment being deleted.</p>
    #[doc(hidden)]
    pub environment: std::option::Option<crate::model::Environment>,
}
impl DeleteEnvironmentOutput {
    /// <p>The detailed data of the environment being deleted.</p>
    pub fn environment(&self) -> std::option::Option<&crate::model::Environment> {
        self.environment.as_ref()
    }
}
/// See [`DeleteEnvironmentOutput`](crate::output::DeleteEnvironmentOutput).
pub mod delete_environment_output {

    /// A builder for [`DeleteEnvironmentOutput`](crate::output::DeleteEnvironmentOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) environment: std::option::Option<crate::model::Environment>,
    }
    impl Builder {
        /// <p>The detailed data of the environment being deleted.</p>
        pub fn environment(mut self, input: crate::model::Environment) -> Self {
            self.environment = Some(input);
            self
        }
        /// <p>The detailed data of the environment being deleted.</p>
        pub fn set_environment(
            mut self,
            input: std::option::Option<crate::model::Environment>,
        ) -> Self {
            self.environment = input;
            self
        }
        /// Consumes the builder and constructs a [`DeleteEnvironmentOutput`](crate::output::DeleteEnvironmentOutput).
        pub fn build(self) -> crate::output::DeleteEnvironmentOutput {
            crate::output::DeleteEnvironmentOutput {
                environment: self.environment,
            }
        }
    }
}
impl DeleteEnvironmentOutput {
    /// Creates a new builder-style object to manufacture [`DeleteEnvironmentOutput`](crate::output::DeleteEnvironmentOutput).
    pub fn builder() -> crate::output::delete_environment_output::Builder {
        crate::output::delete_environment_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateEnvironmentOutput {
    /// <p>The environment detail data that's returned by Proton.</p>
    #[doc(hidden)]
    pub environment: std::option::Option<crate::model::Environment>,
}
impl UpdateEnvironmentOutput {
    /// <p>The environment detail data that's returned by Proton.</p>
    pub fn environment(&self) -> std::option::Option<&crate::model::Environment> {
        self.environment.as_ref()
    }
}
/// See [`UpdateEnvironmentOutput`](crate::output::UpdateEnvironmentOutput).
pub mod update_environment_output {

    /// A builder for [`UpdateEnvironmentOutput`](crate::output::UpdateEnvironmentOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) environment: std::option::Option<crate::model::Environment>,
    }
    impl Builder {
        /// <p>The environment detail data that's returned by Proton.</p>
        pub fn environment(mut self, input: crate::model::Environment) -> Self {
            self.environment = Some(input);
            self
        }
        /// <p>The environment detail data that's returned by Proton.</p>
        pub fn set_environment(
            mut self,
            input: std::option::Option<crate::model::Environment>,
        ) -> Self {
            self.environment = input;
            self
        }
        /// Consumes the builder and constructs a [`UpdateEnvironmentOutput`](crate::output::UpdateEnvironmentOutput).
        pub fn build(self) -> crate::output::UpdateEnvironmentOutput {
            crate::output::UpdateEnvironmentOutput {
                environment: self.environment,
            }
        }
    }
}
impl UpdateEnvironmentOutput {
    /// Creates a new builder-style object to manufacture [`UpdateEnvironmentOutput`](crate::output::UpdateEnvironmentOutput).
    pub fn builder() -> crate::output::update_environment_output::Builder {
        crate::output::update_environment_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetEnvironmentOutput {
    /// <p>The detailed data of the requested environment.</p>
    #[doc(hidden)]
    pub environment: std::option::Option<crate::model::Environment>,
}
impl GetEnvironmentOutput {
    /// <p>The detailed data of the requested environment.</p>
    pub fn environment(&self) -> std::option::Option<&crate::model::Environment> {
        self.environment.as_ref()
    }
}
/// See [`GetEnvironmentOutput`](crate::output::GetEnvironmentOutput).
pub mod get_environment_output {

    /// A builder for [`GetEnvironmentOutput`](crate::output::GetEnvironmentOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) environment: std::option::Option<crate::model::Environment>,
    }
    impl Builder {
        /// <p>The detailed data of the requested environment.</p>
        pub fn environment(mut self, input: crate::model::Environment) -> Self {
            self.environment = Some(input);
            self
        }
        /// <p>The detailed data of the requested environment.</p>
        pub fn set_environment(
            mut self,
            input: std::option::Option<crate::model::Environment>,
        ) -> Self {
            self.environment = input;
            self
        }
        /// Consumes the builder and constructs a [`GetEnvironmentOutput`](crate::output::GetEnvironmentOutput).
        pub fn build(self) -> crate::output::GetEnvironmentOutput {
            crate::output::GetEnvironmentOutput {
                environment: self.environment,
            }
        }
    }
}
impl GetEnvironmentOutput {
    /// Creates a new builder-style object to manufacture [`GetEnvironmentOutput`](crate::output::GetEnvironmentOutput).
    pub fn builder() -> crate::output::get_environment_output::Builder {
        crate::output::get_environment_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListEnvironmentProvisionedResourcesOutput {
    /// <p>A token that indicates the location of the next environment provisioned resource in the array of provisioned resources, after the current requested list of environment provisioned resources.</p>
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
    /// <p>An array of environment provisioned resources.</p>
    #[doc(hidden)]
    pub provisioned_resources:
        std::option::Option<std::vec::Vec<crate::model::ProvisionedResource>>,
}
impl ListEnvironmentProvisionedResourcesOutput {
    /// <p>A token that indicates the location of the next environment provisioned resource in the array of provisioned resources, after the current requested list of environment provisioned resources.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// <p>An array of environment provisioned resources.</p>
    pub fn provisioned_resources(
        &self,
    ) -> std::option::Option<&[crate::model::ProvisionedResource]> {
        self.provisioned_resources.as_deref()
    }
}
/// See [`ListEnvironmentProvisionedResourcesOutput`](crate::output::ListEnvironmentProvisionedResourcesOutput).
pub mod list_environment_provisioned_resources_output {

    /// A builder for [`ListEnvironmentProvisionedResourcesOutput`](crate::output::ListEnvironmentProvisionedResourcesOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) provisioned_resources:
            std::option::Option<std::vec::Vec<crate::model::ProvisionedResource>>,
    }
    impl Builder {
        /// <p>A token that indicates the location of the next environment provisioned resource in the array of provisioned resources, after the current requested list of environment provisioned resources.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>A token that indicates the location of the next environment provisioned resource in the array of provisioned resources, after the current requested list of environment provisioned resources.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Appends an item to `provisioned_resources`.
        ///
        /// To override the contents of this collection use [`set_provisioned_resources`](Self::set_provisioned_resources).
        ///
        /// <p>An array of environment provisioned resources.</p>
        pub fn provisioned_resources(mut self, input: crate::model::ProvisionedResource) -> Self {
            let mut v = self.provisioned_resources.unwrap_or_default();
            v.push(input);
            self.provisioned_resources = Some(v);
            self
        }
        /// <p>An array of environment provisioned resources.</p>
        pub fn set_provisioned_resources(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ProvisionedResource>>,
        ) -> Self {
            self.provisioned_resources = input;
            self
        }
        /// Consumes the builder and constructs a [`ListEnvironmentProvisionedResourcesOutput`](crate::output::ListEnvironmentProvisionedResourcesOutput).
        pub fn build(self) -> crate::output::ListEnvironmentProvisionedResourcesOutput {
            crate::output::ListEnvironmentProvisionedResourcesOutput {
                next_token: self.next_token,
                provisioned_resources: self.provisioned_resources,
            }
        }
    }
}
impl ListEnvironmentProvisionedResourcesOutput {
    /// Creates a new builder-style object to manufacture [`ListEnvironmentProvisionedResourcesOutput`](crate::output::ListEnvironmentProvisionedResourcesOutput).
    pub fn builder() -> crate::output::list_environment_provisioned_resources_output::Builder {
        crate::output::list_environment_provisioned_resources_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListEnvironmentOutputsOutput {
    /// <p>A token that indicates the location of the next environment output in the array of environment outputs, after the current requested list of environment outputs.</p>
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
    /// <p>An array of environment outputs with detail data.</p>
    #[doc(hidden)]
    pub outputs: std::option::Option<std::vec::Vec<crate::model::Output>>,
}
impl ListEnvironmentOutputsOutput {
    /// <p>A token that indicates the location of the next environment output in the array of environment outputs, after the current requested list of environment outputs.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// <p>An array of environment outputs with detail data.</p>
    pub fn outputs(&self) -> std::option::Option<&[crate::model::Output]> {
        self.outputs.as_deref()
    }
}
/// See [`ListEnvironmentOutputsOutput`](crate::output::ListEnvironmentOutputsOutput).
pub mod list_environment_outputs_output {

    /// A builder for [`ListEnvironmentOutputsOutput`](crate::output::ListEnvironmentOutputsOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) outputs: std::option::Option<std::vec::Vec<crate::model::Output>>,
    }
    impl Builder {
        /// <p>A token that indicates the location of the next environment output in the array of environment outputs, after the current requested list of environment outputs.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>A token that indicates the location of the next environment output in the array of environment outputs, after the current requested list of environment outputs.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Appends an item to `outputs`.
        ///
        /// To override the contents of this collection use [`set_outputs`](Self::set_outputs).
        ///
        /// <p>An array of environment outputs with detail data.</p>
        pub fn outputs(mut self, input: crate::model::Output) -> Self {
            let mut v = self.outputs.unwrap_or_default();
            v.push(input);
            self.outputs = Some(v);
            self
        }
        /// <p>An array of environment outputs with detail data.</p>
        pub fn set_outputs(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Output>>,
        ) -> Self {
            self.outputs = input;
            self
        }
        /// Consumes the builder and constructs a [`ListEnvironmentOutputsOutput`](crate::output::ListEnvironmentOutputsOutput).
        pub fn build(self) -> crate::output::ListEnvironmentOutputsOutput {
            crate::output::ListEnvironmentOutputsOutput {
                next_token: self.next_token,
                outputs: self.outputs,
            }
        }
    }
}
impl ListEnvironmentOutputsOutput {
    /// Creates a new builder-style object to manufacture [`ListEnvironmentOutputsOutput`](crate::output::ListEnvironmentOutputsOutput).
    pub fn builder() -> crate::output::list_environment_outputs_output::Builder {
        crate::output::list_environment_outputs_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct RejectEnvironmentAccountConnectionOutput {
    /// <p>The environment connection account detail data that's returned by Proton.</p>
    #[doc(hidden)]
    pub environment_account_connection:
        std::option::Option<crate::model::EnvironmentAccountConnection>,
}
impl RejectEnvironmentAccountConnectionOutput {
    /// <p>The environment connection account detail data that's returned by Proton.</p>
    pub fn environment_account_connection(
        &self,
    ) -> std::option::Option<&crate::model::EnvironmentAccountConnection> {
        self.environment_account_connection.as_ref()
    }
}
/// See [`RejectEnvironmentAccountConnectionOutput`](crate::output::RejectEnvironmentAccountConnectionOutput).
pub mod reject_environment_account_connection_output {

    /// A builder for [`RejectEnvironmentAccountConnectionOutput`](crate::output::RejectEnvironmentAccountConnectionOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) environment_account_connection:
            std::option::Option<crate::model::EnvironmentAccountConnection>,
    }
    impl Builder {
        /// <p>The environment connection account detail data that's returned by Proton.</p>
        pub fn environment_account_connection(
            mut self,
            input: crate::model::EnvironmentAccountConnection,
        ) -> Self {
            self.environment_account_connection = Some(input);
            self
        }
        /// <p>The environment connection account detail data that's returned by Proton.</p>
        pub fn set_environment_account_connection(
            mut self,
            input: std::option::Option<crate::model::EnvironmentAccountConnection>,
        ) -> Self {
            self.environment_account_connection = input;
            self
        }
        /// Consumes the builder and constructs a [`RejectEnvironmentAccountConnectionOutput`](crate::output::RejectEnvironmentAccountConnectionOutput).
        pub fn build(self) -> crate::output::RejectEnvironmentAccountConnectionOutput {
            crate::output::RejectEnvironmentAccountConnectionOutput {
                environment_account_connection: self.environment_account_connection,
            }
        }
    }
}
impl RejectEnvironmentAccountConnectionOutput {
    /// Creates a new builder-style object to manufacture [`RejectEnvironmentAccountConnectionOutput`](crate::output::RejectEnvironmentAccountConnectionOutput).
    pub fn builder() -> crate::output::reject_environment_account_connection_output::Builder {
        crate::output::reject_environment_account_connection_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct AcceptEnvironmentAccountConnectionOutput {
    /// <p>The environment account connection data that's returned by Proton.</p>
    #[doc(hidden)]
    pub environment_account_connection:
        std::option::Option<crate::model::EnvironmentAccountConnection>,
}
impl AcceptEnvironmentAccountConnectionOutput {
    /// <p>The environment account connection data that's returned by Proton.</p>
    pub fn environment_account_connection(
        &self,
    ) -> std::option::Option<&crate::model::EnvironmentAccountConnection> {
        self.environment_account_connection.as_ref()
    }
}
/// See [`AcceptEnvironmentAccountConnectionOutput`](crate::output::AcceptEnvironmentAccountConnectionOutput).
pub mod accept_environment_account_connection_output {

    /// A builder for [`AcceptEnvironmentAccountConnectionOutput`](crate::output::AcceptEnvironmentAccountConnectionOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) environment_account_connection:
            std::option::Option<crate::model::EnvironmentAccountConnection>,
    }
    impl Builder {
        /// <p>The environment account connection data that's returned by Proton.</p>
        pub fn environment_account_connection(
            mut self,
            input: crate::model::EnvironmentAccountConnection,
        ) -> Self {
            self.environment_account_connection = Some(input);
            self
        }
        /// <p>The environment account connection data that's returned by Proton.</p>
        pub fn set_environment_account_connection(
            mut self,
            input: std::option::Option<crate::model::EnvironmentAccountConnection>,
        ) -> Self {
            self.environment_account_connection = input;
            self
        }
        /// Consumes the builder and constructs a [`AcceptEnvironmentAccountConnectionOutput`](crate::output::AcceptEnvironmentAccountConnectionOutput).
        pub fn build(self) -> crate::output::AcceptEnvironmentAccountConnectionOutput {
            crate::output::AcceptEnvironmentAccountConnectionOutput {
                environment_account_connection: self.environment_account_connection,
            }
        }
    }
}
impl AcceptEnvironmentAccountConnectionOutput {
    /// Creates a new builder-style object to manufacture [`AcceptEnvironmentAccountConnectionOutput`](crate::output::AcceptEnvironmentAccountConnectionOutput).
    pub fn builder() -> crate::output::accept_environment_account_connection_output::Builder {
        crate::output::accept_environment_account_connection_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListEnvironmentAccountConnectionsOutput {
    /// <p>An array of environment account connections with details that's returned by Proton. </p>
    #[doc(hidden)]
    pub environment_account_connections:
        std::option::Option<std::vec::Vec<crate::model::EnvironmentAccountConnectionSummary>>,
    /// <p>A token that indicates the location of the next environment account connection in the array of environment account connections, after the current requested list of environment account connections.</p>
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
}
impl ListEnvironmentAccountConnectionsOutput {
    /// <p>An array of environment account connections with details that's returned by Proton. </p>
    pub fn environment_account_connections(
        &self,
    ) -> std::option::Option<&[crate::model::EnvironmentAccountConnectionSummary]> {
        self.environment_account_connections.as_deref()
    }
    /// <p>A token that indicates the location of the next environment account connection in the array of environment account connections, after the current requested list of environment account connections.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
/// See [`ListEnvironmentAccountConnectionsOutput`](crate::output::ListEnvironmentAccountConnectionsOutput).
pub mod list_environment_account_connections_output {

    /// A builder for [`ListEnvironmentAccountConnectionsOutput`](crate::output::ListEnvironmentAccountConnectionsOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) environment_account_connections:
            std::option::Option<std::vec::Vec<crate::model::EnvironmentAccountConnectionSummary>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `environment_account_connections`.
        ///
        /// To override the contents of this collection use [`set_environment_account_connections`](Self::set_environment_account_connections).
        ///
        /// <p>An array of environment account connections with details that's returned by Proton. </p>
        pub fn environment_account_connections(
            mut self,
            input: crate::model::EnvironmentAccountConnectionSummary,
        ) -> Self {
            let mut v = self.environment_account_connections.unwrap_or_default();
            v.push(input);
            self.environment_account_connections = Some(v);
            self
        }
        /// <p>An array of environment account connections with details that's returned by Proton. </p>
        pub fn set_environment_account_connections(
            mut self,
            input: std::option::Option<
                std::vec::Vec<crate::model::EnvironmentAccountConnectionSummary>,
            >,
        ) -> Self {
            self.environment_account_connections = input;
            self
        }
        /// <p>A token that indicates the location of the next environment account connection in the array of environment account connections, after the current requested list of environment account connections.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>A token that indicates the location of the next environment account connection in the array of environment account connections, after the current requested list of environment account connections.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`ListEnvironmentAccountConnectionsOutput`](crate::output::ListEnvironmentAccountConnectionsOutput).
        pub fn build(self) -> crate::output::ListEnvironmentAccountConnectionsOutput {
            crate::output::ListEnvironmentAccountConnectionsOutput {
                environment_account_connections: self.environment_account_connections,
                next_token: self.next_token,
            }
        }
    }
}
impl ListEnvironmentAccountConnectionsOutput {
    /// Creates a new builder-style object to manufacture [`ListEnvironmentAccountConnectionsOutput`](crate::output::ListEnvironmentAccountConnectionsOutput).
    pub fn builder() -> crate::output::list_environment_account_connections_output::Builder {
        crate::output::list_environment_account_connections_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateEnvironmentAccountConnectionOutput {
    /// <p>The environment account connection detail data that's returned by Proton.</p>
    #[doc(hidden)]
    pub environment_account_connection:
        std::option::Option<crate::model::EnvironmentAccountConnection>,
}
impl CreateEnvironmentAccountConnectionOutput {
    /// <p>The environment account connection detail data that's returned by Proton.</p>
    pub fn environment_account_connection(
        &self,
    ) -> std::option::Option<&crate::model::EnvironmentAccountConnection> {
        self.environment_account_connection.as_ref()
    }
}
/// See [`CreateEnvironmentAccountConnectionOutput`](crate::output::CreateEnvironmentAccountConnectionOutput).
pub mod create_environment_account_connection_output {

    /// A builder for [`CreateEnvironmentAccountConnectionOutput`](crate::output::CreateEnvironmentAccountConnectionOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) environment_account_connection:
            std::option::Option<crate::model::EnvironmentAccountConnection>,
    }
    impl Builder {
        /// <p>The environment account connection detail data that's returned by Proton.</p>
        pub fn environment_account_connection(
            mut self,
            input: crate::model::EnvironmentAccountConnection,
        ) -> Self {
            self.environment_account_connection = Some(input);
            self
        }
        /// <p>The environment account connection detail data that's returned by Proton.</p>
        pub fn set_environment_account_connection(
            mut self,
            input: std::option::Option<crate::model::EnvironmentAccountConnection>,
        ) -> Self {
            self.environment_account_connection = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateEnvironmentAccountConnectionOutput`](crate::output::CreateEnvironmentAccountConnectionOutput).
        pub fn build(self) -> crate::output::CreateEnvironmentAccountConnectionOutput {
            crate::output::CreateEnvironmentAccountConnectionOutput {
                environment_account_connection: self.environment_account_connection,
            }
        }
    }
}
impl CreateEnvironmentAccountConnectionOutput {
    /// Creates a new builder-style object to manufacture [`CreateEnvironmentAccountConnectionOutput`](crate::output::CreateEnvironmentAccountConnectionOutput).
    pub fn builder() -> crate::output::create_environment_account_connection_output::Builder {
        crate::output::create_environment_account_connection_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteEnvironmentAccountConnectionOutput {
    /// <p>The detailed data of the environment account connection being deleted.</p>
    #[doc(hidden)]
    pub environment_account_connection:
        std::option::Option<crate::model::EnvironmentAccountConnection>,
}
impl DeleteEnvironmentAccountConnectionOutput {
    /// <p>The detailed data of the environment account connection being deleted.</p>
    pub fn environment_account_connection(
        &self,
    ) -> std::option::Option<&crate::model::EnvironmentAccountConnection> {
        self.environment_account_connection.as_ref()
    }
}
/// See [`DeleteEnvironmentAccountConnectionOutput`](crate::output::DeleteEnvironmentAccountConnectionOutput).
pub mod delete_environment_account_connection_output {

    /// A builder for [`DeleteEnvironmentAccountConnectionOutput`](crate::output::DeleteEnvironmentAccountConnectionOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) environment_account_connection:
            std::option::Option<crate::model::EnvironmentAccountConnection>,
    }
    impl Builder {
        /// <p>The detailed data of the environment account connection being deleted.</p>
        pub fn environment_account_connection(
            mut self,
            input: crate::model::EnvironmentAccountConnection,
        ) -> Self {
            self.environment_account_connection = Some(input);
            self
        }
        /// <p>The detailed data of the environment account connection being deleted.</p>
        pub fn set_environment_account_connection(
            mut self,
            input: std::option::Option<crate::model::EnvironmentAccountConnection>,
        ) -> Self {
            self.environment_account_connection = input;
            self
        }
        /// Consumes the builder and constructs a [`DeleteEnvironmentAccountConnectionOutput`](crate::output::DeleteEnvironmentAccountConnectionOutput).
        pub fn build(self) -> crate::output::DeleteEnvironmentAccountConnectionOutput {
            crate::output::DeleteEnvironmentAccountConnectionOutput {
                environment_account_connection: self.environment_account_connection,
            }
        }
    }
}
impl DeleteEnvironmentAccountConnectionOutput {
    /// Creates a new builder-style object to manufacture [`DeleteEnvironmentAccountConnectionOutput`](crate::output::DeleteEnvironmentAccountConnectionOutput).
    pub fn builder() -> crate::output::delete_environment_account_connection_output::Builder {
        crate::output::delete_environment_account_connection_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateEnvironmentAccountConnectionOutput {
    /// <p>The environment account connection detail data that's returned by Proton.</p>
    #[doc(hidden)]
    pub environment_account_connection:
        std::option::Option<crate::model::EnvironmentAccountConnection>,
}
impl UpdateEnvironmentAccountConnectionOutput {
    /// <p>The environment account connection detail data that's returned by Proton.</p>
    pub fn environment_account_connection(
        &self,
    ) -> std::option::Option<&crate::model::EnvironmentAccountConnection> {
        self.environment_account_connection.as_ref()
    }
}
/// See [`UpdateEnvironmentAccountConnectionOutput`](crate::output::UpdateEnvironmentAccountConnectionOutput).
pub mod update_environment_account_connection_output {

    /// A builder for [`UpdateEnvironmentAccountConnectionOutput`](crate::output::UpdateEnvironmentAccountConnectionOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) environment_account_connection:
            std::option::Option<crate::model::EnvironmentAccountConnection>,
    }
    impl Builder {
        /// <p>The environment account connection detail data that's returned by Proton.</p>
        pub fn environment_account_connection(
            mut self,
            input: crate::model::EnvironmentAccountConnection,
        ) -> Self {
            self.environment_account_connection = Some(input);
            self
        }
        /// <p>The environment account connection detail data that's returned by Proton.</p>
        pub fn set_environment_account_connection(
            mut self,
            input: std::option::Option<crate::model::EnvironmentAccountConnection>,
        ) -> Self {
            self.environment_account_connection = input;
            self
        }
        /// Consumes the builder and constructs a [`UpdateEnvironmentAccountConnectionOutput`](crate::output::UpdateEnvironmentAccountConnectionOutput).
        pub fn build(self) -> crate::output::UpdateEnvironmentAccountConnectionOutput {
            crate::output::UpdateEnvironmentAccountConnectionOutput {
                environment_account_connection: self.environment_account_connection,
            }
        }
    }
}
impl UpdateEnvironmentAccountConnectionOutput {
    /// Creates a new builder-style object to manufacture [`UpdateEnvironmentAccountConnectionOutput`](crate::output::UpdateEnvironmentAccountConnectionOutput).
    pub fn builder() -> crate::output::update_environment_account_connection_output::Builder {
        crate::output::update_environment_account_connection_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetEnvironmentAccountConnectionOutput {
    /// <p>The detailed data of the requested environment account connection.</p>
    #[doc(hidden)]
    pub environment_account_connection:
        std::option::Option<crate::model::EnvironmentAccountConnection>,
}
impl GetEnvironmentAccountConnectionOutput {
    /// <p>The detailed data of the requested environment account connection.</p>
    pub fn environment_account_connection(
        &self,
    ) -> std::option::Option<&crate::model::EnvironmentAccountConnection> {
        self.environment_account_connection.as_ref()
    }
}
/// See [`GetEnvironmentAccountConnectionOutput`](crate::output::GetEnvironmentAccountConnectionOutput).
pub mod get_environment_account_connection_output {

    /// A builder for [`GetEnvironmentAccountConnectionOutput`](crate::output::GetEnvironmentAccountConnectionOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) environment_account_connection:
            std::option::Option<crate::model::EnvironmentAccountConnection>,
    }
    impl Builder {
        /// <p>The detailed data of the requested environment account connection.</p>
        pub fn environment_account_connection(
            mut self,
            input: crate::model::EnvironmentAccountConnection,
        ) -> Self {
            self.environment_account_connection = Some(input);
            self
        }
        /// <p>The detailed data of the requested environment account connection.</p>
        pub fn set_environment_account_connection(
            mut self,
            input: std::option::Option<crate::model::EnvironmentAccountConnection>,
        ) -> Self {
            self.environment_account_connection = input;
            self
        }
        /// Consumes the builder and constructs a [`GetEnvironmentAccountConnectionOutput`](crate::output::GetEnvironmentAccountConnectionOutput).
        pub fn build(self) -> crate::output::GetEnvironmentAccountConnectionOutput {
            crate::output::GetEnvironmentAccountConnectionOutput {
                environment_account_connection: self.environment_account_connection,
            }
        }
    }
}
impl GetEnvironmentAccountConnectionOutput {
    /// Creates a new builder-style object to manufacture [`GetEnvironmentAccountConnectionOutput`](crate::output::GetEnvironmentAccountConnectionOutput).
    pub fn builder() -> crate::output::get_environment_account_connection_output::Builder {
        crate::output::get_environment_account_connection_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListComponentsOutput {
    /// <p>A token that indicates the location of the next component in the array of components, after the current requested list of components.</p>
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
    /// <p>An array of components with summary data.</p>
    #[doc(hidden)]
    pub components: std::option::Option<std::vec::Vec<crate::model::ComponentSummary>>,
}
impl ListComponentsOutput {
    /// <p>A token that indicates the location of the next component in the array of components, after the current requested list of components.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// <p>An array of components with summary data.</p>
    pub fn components(&self) -> std::option::Option<&[crate::model::ComponentSummary]> {
        self.components.as_deref()
    }
}
/// See [`ListComponentsOutput`](crate::output::ListComponentsOutput).
pub mod list_components_output {

    /// A builder for [`ListComponentsOutput`](crate::output::ListComponentsOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) components: std::option::Option<std::vec::Vec<crate::model::ComponentSummary>>,
    }
    impl Builder {
        /// <p>A token that indicates the location of the next component in the array of components, after the current requested list of components.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>A token that indicates the location of the next component in the array of components, after the current requested list of components.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Appends an item to `components`.
        ///
        /// To override the contents of this collection use [`set_components`](Self::set_components).
        ///
        /// <p>An array of components with summary data.</p>
        pub fn components(mut self, input: crate::model::ComponentSummary) -> Self {
            let mut v = self.components.unwrap_or_default();
            v.push(input);
            self.components = Some(v);
            self
        }
        /// <p>An array of components with summary data.</p>
        pub fn set_components(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ComponentSummary>>,
        ) -> Self {
            self.components = input;
            self
        }
        /// Consumes the builder and constructs a [`ListComponentsOutput`](crate::output::ListComponentsOutput).
        pub fn build(self) -> crate::output::ListComponentsOutput {
            crate::output::ListComponentsOutput {
                next_token: self.next_token,
                components: self.components,
            }
        }
    }
}
impl ListComponentsOutput {
    /// Creates a new builder-style object to manufacture [`ListComponentsOutput`](crate::output::ListComponentsOutput).
    pub fn builder() -> crate::output::list_components_output::Builder {
        crate::output::list_components_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateComponentOutput {
    /// <p>The detailed data of the created component.</p>
    #[doc(hidden)]
    pub component: std::option::Option<crate::model::Component>,
}
impl CreateComponentOutput {
    /// <p>The detailed data of the created component.</p>
    pub fn component(&self) -> std::option::Option<&crate::model::Component> {
        self.component.as_ref()
    }
}
/// See [`CreateComponentOutput`](crate::output::CreateComponentOutput).
pub mod create_component_output {

    /// A builder for [`CreateComponentOutput`](crate::output::CreateComponentOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) component: std::option::Option<crate::model::Component>,
    }
    impl Builder {
        /// <p>The detailed data of the created component.</p>
        pub fn component(mut self, input: crate::model::Component) -> Self {
            self.component = Some(input);
            self
        }
        /// <p>The detailed data of the created component.</p>
        pub fn set_component(
            mut self,
            input: std::option::Option<crate::model::Component>,
        ) -> Self {
            self.component = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateComponentOutput`](crate::output::CreateComponentOutput).
        pub fn build(self) -> crate::output::CreateComponentOutput {
            crate::output::CreateComponentOutput {
                component: self.component,
            }
        }
    }
}
impl CreateComponentOutput {
    /// Creates a new builder-style object to manufacture [`CreateComponentOutput`](crate::output::CreateComponentOutput).
    pub fn builder() -> crate::output::create_component_output::Builder {
        crate::output::create_component_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteComponentOutput {
    /// <p>The detailed data of the component being deleted.</p>
    #[doc(hidden)]
    pub component: std::option::Option<crate::model::Component>,
}
impl DeleteComponentOutput {
    /// <p>The detailed data of the component being deleted.</p>
    pub fn component(&self) -> std::option::Option<&crate::model::Component> {
        self.component.as_ref()
    }
}
/// See [`DeleteComponentOutput`](crate::output::DeleteComponentOutput).
pub mod delete_component_output {

    /// A builder for [`DeleteComponentOutput`](crate::output::DeleteComponentOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) component: std::option::Option<crate::model::Component>,
    }
    impl Builder {
        /// <p>The detailed data of the component being deleted.</p>
        pub fn component(mut self, input: crate::model::Component) -> Self {
            self.component = Some(input);
            self
        }
        /// <p>The detailed data of the component being deleted.</p>
        pub fn set_component(
            mut self,
            input: std::option::Option<crate::model::Component>,
        ) -> Self {
            self.component = input;
            self
        }
        /// Consumes the builder and constructs a [`DeleteComponentOutput`](crate::output::DeleteComponentOutput).
        pub fn build(self) -> crate::output::DeleteComponentOutput {
            crate::output::DeleteComponentOutput {
                component: self.component,
            }
        }
    }
}
impl DeleteComponentOutput {
    /// Creates a new builder-style object to manufacture [`DeleteComponentOutput`](crate::output::DeleteComponentOutput).
    pub fn builder() -> crate::output::delete_component_output::Builder {
        crate::output::delete_component_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateComponentOutput {
    /// <p>The detailed data of the updated component.</p>
    #[doc(hidden)]
    pub component: std::option::Option<crate::model::Component>,
}
impl UpdateComponentOutput {
    /// <p>The detailed data of the updated component.</p>
    pub fn component(&self) -> std::option::Option<&crate::model::Component> {
        self.component.as_ref()
    }
}
/// See [`UpdateComponentOutput`](crate::output::UpdateComponentOutput).
pub mod update_component_output {

    /// A builder for [`UpdateComponentOutput`](crate::output::UpdateComponentOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) component: std::option::Option<crate::model::Component>,
    }
    impl Builder {
        /// <p>The detailed data of the updated component.</p>
        pub fn component(mut self, input: crate::model::Component) -> Self {
            self.component = Some(input);
            self
        }
        /// <p>The detailed data of the updated component.</p>
        pub fn set_component(
            mut self,
            input: std::option::Option<crate::model::Component>,
        ) -> Self {
            self.component = input;
            self
        }
        /// Consumes the builder and constructs a [`UpdateComponentOutput`](crate::output::UpdateComponentOutput).
        pub fn build(self) -> crate::output::UpdateComponentOutput {
            crate::output::UpdateComponentOutput {
                component: self.component,
            }
        }
    }
}
impl UpdateComponentOutput {
    /// Creates a new builder-style object to manufacture [`UpdateComponentOutput`](crate::output::UpdateComponentOutput).
    pub fn builder() -> crate::output::update_component_output::Builder {
        crate::output::update_component_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetComponentOutput {
    /// <p>The detailed data of the requested component.</p>
    #[doc(hidden)]
    pub component: std::option::Option<crate::model::Component>,
}
impl GetComponentOutput {
    /// <p>The detailed data of the requested component.</p>
    pub fn component(&self) -> std::option::Option<&crate::model::Component> {
        self.component.as_ref()
    }
}
/// See [`GetComponentOutput`](crate::output::GetComponentOutput).
pub mod get_component_output {

    /// A builder for [`GetComponentOutput`](crate::output::GetComponentOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) component: std::option::Option<crate::model::Component>,
    }
    impl Builder {
        /// <p>The detailed data of the requested component.</p>
        pub fn component(mut self, input: crate::model::Component) -> Self {
            self.component = Some(input);
            self
        }
        /// <p>The detailed data of the requested component.</p>
        pub fn set_component(
            mut self,
            input: std::option::Option<crate::model::Component>,
        ) -> Self {
            self.component = input;
            self
        }
        /// Consumes the builder and constructs a [`GetComponentOutput`](crate::output::GetComponentOutput).
        pub fn build(self) -> crate::output::GetComponentOutput {
            crate::output::GetComponentOutput {
                component: self.component,
            }
        }
    }
}
impl GetComponentOutput {
    /// Creates a new builder-style object to manufacture [`GetComponentOutput`](crate::output::GetComponentOutput).
    pub fn builder() -> crate::output::get_component_output::Builder {
        crate::output::get_component_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListComponentProvisionedResourcesOutput {
    /// <p>A token that indicates the location of the next provisioned resource in the array of provisioned resources, after the current requested list of provisioned resources.</p>
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
    /// <p>An array of provisioned resources for a component.</p>
    #[doc(hidden)]
    pub provisioned_resources:
        std::option::Option<std::vec::Vec<crate::model::ProvisionedResource>>,
}
impl ListComponentProvisionedResourcesOutput {
    /// <p>A token that indicates the location of the next provisioned resource in the array of provisioned resources, after the current requested list of provisioned resources.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// <p>An array of provisioned resources for a component.</p>
    pub fn provisioned_resources(
        &self,
    ) -> std::option::Option<&[crate::model::ProvisionedResource]> {
        self.provisioned_resources.as_deref()
    }
}
/// See [`ListComponentProvisionedResourcesOutput`](crate::output::ListComponentProvisionedResourcesOutput).
pub mod list_component_provisioned_resources_output {

    /// A builder for [`ListComponentProvisionedResourcesOutput`](crate::output::ListComponentProvisionedResourcesOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) provisioned_resources:
            std::option::Option<std::vec::Vec<crate::model::ProvisionedResource>>,
    }
    impl Builder {
        /// <p>A token that indicates the location of the next provisioned resource in the array of provisioned resources, after the current requested list of provisioned resources.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>A token that indicates the location of the next provisioned resource in the array of provisioned resources, after the current requested list of provisioned resources.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Appends an item to `provisioned_resources`.
        ///
        /// To override the contents of this collection use [`set_provisioned_resources`](Self::set_provisioned_resources).
        ///
        /// <p>An array of provisioned resources for a component.</p>
        pub fn provisioned_resources(mut self, input: crate::model::ProvisionedResource) -> Self {
            let mut v = self.provisioned_resources.unwrap_or_default();
            v.push(input);
            self.provisioned_resources = Some(v);
            self
        }
        /// <p>An array of provisioned resources for a component.</p>
        pub fn set_provisioned_resources(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ProvisionedResource>>,
        ) -> Self {
            self.provisioned_resources = input;
            self
        }
        /// Consumes the builder and constructs a [`ListComponentProvisionedResourcesOutput`](crate::output::ListComponentProvisionedResourcesOutput).
        pub fn build(self) -> crate::output::ListComponentProvisionedResourcesOutput {
            crate::output::ListComponentProvisionedResourcesOutput {
                next_token: self.next_token,
                provisioned_resources: self.provisioned_resources,
            }
        }
    }
}
impl ListComponentProvisionedResourcesOutput {
    /// Creates a new builder-style object to manufacture [`ListComponentProvisionedResourcesOutput`](crate::output::ListComponentProvisionedResourcesOutput).
    pub fn builder() -> crate::output::list_component_provisioned_resources_output::Builder {
        crate::output::list_component_provisioned_resources_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListComponentOutputsOutput {
    /// <p>A token that indicates the location of the next output in the array of outputs, after the list of outputs that was previously requested.</p>
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
    /// <p>An array of component Infrastructure as Code (IaC) outputs.</p>
    #[doc(hidden)]
    pub outputs: std::option::Option<std::vec::Vec<crate::model::Output>>,
}
impl ListComponentOutputsOutput {
    /// <p>A token that indicates the location of the next output in the array of outputs, after the list of outputs that was previously requested.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// <p>An array of component Infrastructure as Code (IaC) outputs.</p>
    pub fn outputs(&self) -> std::option::Option<&[crate::model::Output]> {
        self.outputs.as_deref()
    }
}
/// See [`ListComponentOutputsOutput`](crate::output::ListComponentOutputsOutput).
pub mod list_component_outputs_output {

    /// A builder for [`ListComponentOutputsOutput`](crate::output::ListComponentOutputsOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) outputs: std::option::Option<std::vec::Vec<crate::model::Output>>,
    }
    impl Builder {
        /// <p>A token that indicates the location of the next output in the array of outputs, after the list of outputs that was previously requested.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>A token that indicates the location of the next output in the array of outputs, after the list of outputs that was previously requested.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Appends an item to `outputs`.
        ///
        /// To override the contents of this collection use [`set_outputs`](Self::set_outputs).
        ///
        /// <p>An array of component Infrastructure as Code (IaC) outputs.</p>
        pub fn outputs(mut self, input: crate::model::Output) -> Self {
            let mut v = self.outputs.unwrap_or_default();
            v.push(input);
            self.outputs = Some(v);
            self
        }
        /// <p>An array of component Infrastructure as Code (IaC) outputs.</p>
        pub fn set_outputs(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Output>>,
        ) -> Self {
            self.outputs = input;
            self
        }
        /// Consumes the builder and constructs a [`ListComponentOutputsOutput`](crate::output::ListComponentOutputsOutput).
        pub fn build(self) -> crate::output::ListComponentOutputsOutput {
            crate::output::ListComponentOutputsOutput {
                next_token: self.next_token,
                outputs: self.outputs,
            }
        }
    }
}
impl ListComponentOutputsOutput {
    /// Creates a new builder-style object to manufacture [`ListComponentOutputsOutput`](crate::output::ListComponentOutputsOutput).
    pub fn builder() -> crate::output::list_component_outputs_output::Builder {
        crate::output::list_component_outputs_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateAccountSettingsOutput {
    /// <p>The Proton pipeline service role and repository data shared across the Amazon Web Services account.</p>
    #[doc(hidden)]
    pub account_settings: std::option::Option<crate::model::AccountSettings>,
}
impl UpdateAccountSettingsOutput {
    /// <p>The Proton pipeline service role and repository data shared across the Amazon Web Services account.</p>
    pub fn account_settings(&self) -> std::option::Option<&crate::model::AccountSettings> {
        self.account_settings.as_ref()
    }
}
/// See [`UpdateAccountSettingsOutput`](crate::output::UpdateAccountSettingsOutput).
pub mod update_account_settings_output {

    /// A builder for [`UpdateAccountSettingsOutput`](crate::output::UpdateAccountSettingsOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) account_settings: std::option::Option<crate::model::AccountSettings>,
    }
    impl Builder {
        /// <p>The Proton pipeline service role and repository data shared across the Amazon Web Services account.</p>
        pub fn account_settings(mut self, input: crate::model::AccountSettings) -> Self {
            self.account_settings = Some(input);
            self
        }
        /// <p>The Proton pipeline service role and repository data shared across the Amazon Web Services account.</p>
        pub fn set_account_settings(
            mut self,
            input: std::option::Option<crate::model::AccountSettings>,
        ) -> Self {
            self.account_settings = input;
            self
        }
        /// Consumes the builder and constructs a [`UpdateAccountSettingsOutput`](crate::output::UpdateAccountSettingsOutput).
        pub fn build(self) -> crate::output::UpdateAccountSettingsOutput {
            crate::output::UpdateAccountSettingsOutput {
                account_settings: self.account_settings,
            }
        }
    }
}
impl UpdateAccountSettingsOutput {
    /// Creates a new builder-style object to manufacture [`UpdateAccountSettingsOutput`](crate::output::UpdateAccountSettingsOutput).
    pub fn builder() -> crate::output::update_account_settings_output::Builder {
        crate::output::update_account_settings_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetAccountSettingsOutput {
    /// <p>The Proton pipeline service role detail data that's returned by Proton.</p>
    #[doc(hidden)]
    pub account_settings: std::option::Option<crate::model::AccountSettings>,
}
impl GetAccountSettingsOutput {
    /// <p>The Proton pipeline service role detail data that's returned by Proton.</p>
    pub fn account_settings(&self) -> std::option::Option<&crate::model::AccountSettings> {
        self.account_settings.as_ref()
    }
}
/// See [`GetAccountSettingsOutput`](crate::output::GetAccountSettingsOutput).
pub mod get_account_settings_output {

    /// A builder for [`GetAccountSettingsOutput`](crate::output::GetAccountSettingsOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) account_settings: std::option::Option<crate::model::AccountSettings>,
    }
    impl Builder {
        /// <p>The Proton pipeline service role detail data that's returned by Proton.</p>
        pub fn account_settings(mut self, input: crate::model::AccountSettings) -> Self {
            self.account_settings = Some(input);
            self
        }
        /// <p>The Proton pipeline service role detail data that's returned by Proton.</p>
        pub fn set_account_settings(
            mut self,
            input: std::option::Option<crate::model::AccountSettings>,
        ) -> Self {
            self.account_settings = input;
            self
        }
        /// Consumes the builder and constructs a [`GetAccountSettingsOutput`](crate::output::GetAccountSettingsOutput).
        pub fn build(self) -> crate::output::GetAccountSettingsOutput {
            crate::output::GetAccountSettingsOutput {
                account_settings: self.account_settings,
            }
        }
    }
}
impl GetAccountSettingsOutput {
    /// Creates a new builder-style object to manufacture [`GetAccountSettingsOutput`](crate::output::GetAccountSettingsOutput).
    pub fn builder() -> crate::output::get_account_settings_output::Builder {
        crate::output::get_account_settings_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UntagResourceOutput {}
/// See [`UntagResourceOutput`](crate::output::UntagResourceOutput).
pub mod untag_resource_output {

    /// A builder for [`UntagResourceOutput`](crate::output::UntagResourceOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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, std::fmt::Debug)]
pub struct TagResourceOutput {}
/// See [`TagResourceOutput`](crate::output::TagResourceOutput).
pub mod tag_resource_output {

    /// A builder for [`TagResourceOutput`](crate::output::TagResourceOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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, std::fmt::Debug)]
pub struct NotifyResourceDeploymentStatusChangeOutput {}
/// See [`NotifyResourceDeploymentStatusChangeOutput`](crate::output::NotifyResourceDeploymentStatusChangeOutput).
pub mod notify_resource_deployment_status_change_output {

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListTagsForResourceOutput {
    /// <p>A list of resource tags with detail data.</p>
    #[doc(hidden)]
    pub tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
    /// <p>A token that indicates the location of the next resource tag in the array of resource tags, after the current requested list of resource tags.</p>
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
}
impl ListTagsForResourceOutput {
    /// <p>A list of resource tags with detail data.</p>
    pub fn tags(&self) -> std::option::Option<&[crate::model::Tag]> {
        self.tags.as_deref()
    }
    /// <p>A token that indicates the location of the next resource tag in the array of resource tags, after the current requested list of resource tags.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
/// See [`ListTagsForResourceOutput`](crate::output::ListTagsForResourceOutput).
pub mod list_tags_for_resource_output {

    /// A builder for [`ListTagsForResourceOutput`](crate::output::ListTagsForResourceOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `tags`.
        ///
        /// To override the contents of this collection use [`set_tags`](Self::set_tags).
        ///
        /// <p>A list of resource tags with detail data.</p>
        pub fn tags(mut self, input: crate::model::Tag) -> Self {
            let mut v = self.tags.unwrap_or_default();
            v.push(input);
            self.tags = Some(v);
            self
        }
        /// <p>A list of resource tags with detail data.</p>
        pub fn set_tags(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
        ) -> Self {
            self.tags = input;
            self
        }
        /// <p>A token that indicates the location of the next resource tag in the array of resource tags, after the current requested list of resource tags.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>A token that indicates the location of the next resource tag in the array of resource tags, after the current requested list of resource tags.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`ListTagsForResourceOutput`](crate::output::ListTagsForResourceOutput).
        pub fn build(self) -> crate::output::ListTagsForResourceOutput {
            crate::output::ListTagsForResourceOutput {
                tags: self.tags,
                next_token: self.next_token,
            }
        }
    }
}
impl ListTagsForResourceOutput {
    /// Creates a new builder-style object to manufacture [`ListTagsForResourceOutput`](crate::output::ListTagsForResourceOutput).
    pub fn builder() -> crate::output::list_tags_for_resource_output::Builder {
        crate::output::list_tags_for_resource_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListRepositorySyncDefinitionsOutput {
    /// <p>A token that indicates the location of the next repository sync definition in the array of repository sync definitions, after the current requested list of repository sync definitions.</p>
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
    /// <p>An array of repository sync definitions.</p>
    #[doc(hidden)]
    pub sync_definitions:
        std::option::Option<std::vec::Vec<crate::model::RepositorySyncDefinition>>,
}
impl ListRepositorySyncDefinitionsOutput {
    /// <p>A token that indicates the location of the next repository sync definition in the array of repository sync definitions, after the current requested list of repository sync definitions.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
    /// <p>An array of repository sync definitions.</p>
    pub fn sync_definitions(
        &self,
    ) -> std::option::Option<&[crate::model::RepositorySyncDefinition]> {
        self.sync_definitions.as_deref()
    }
}
/// See [`ListRepositorySyncDefinitionsOutput`](crate::output::ListRepositorySyncDefinitionsOutput).
pub mod list_repository_sync_definitions_output {

    /// A builder for [`ListRepositorySyncDefinitionsOutput`](crate::output::ListRepositorySyncDefinitionsOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) next_token: std::option::Option<std::string::String>,
        pub(crate) sync_definitions:
            std::option::Option<std::vec::Vec<crate::model::RepositorySyncDefinition>>,
    }
    impl Builder {
        /// <p>A token that indicates the location of the next repository sync definition in the array of repository sync definitions, after the current requested list of repository sync definitions.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>A token that indicates the location of the next repository sync definition in the array of repository sync definitions, after the current requested list of repository sync definitions.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Appends an item to `sync_definitions`.
        ///
        /// To override the contents of this collection use [`set_sync_definitions`](Self::set_sync_definitions).
        ///
        /// <p>An array of repository sync definitions.</p>
        pub fn sync_definitions(mut self, input: crate::model::RepositorySyncDefinition) -> Self {
            let mut v = self.sync_definitions.unwrap_or_default();
            v.push(input);
            self.sync_definitions = Some(v);
            self
        }
        /// <p>An array of repository sync definitions.</p>
        pub fn set_sync_definitions(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::RepositorySyncDefinition>>,
        ) -> Self {
            self.sync_definitions = input;
            self
        }
        /// Consumes the builder and constructs a [`ListRepositorySyncDefinitionsOutput`](crate::output::ListRepositorySyncDefinitionsOutput).
        pub fn build(self) -> crate::output::ListRepositorySyncDefinitionsOutput {
            crate::output::ListRepositorySyncDefinitionsOutput {
                next_token: self.next_token,
                sync_definitions: self.sync_definitions,
            }
        }
    }
}
impl ListRepositorySyncDefinitionsOutput {
    /// Creates a new builder-style object to manufacture [`ListRepositorySyncDefinitionsOutput`](crate::output::ListRepositorySyncDefinitionsOutput).
    pub fn builder() -> crate::output::list_repository_sync_definitions_output::Builder {
        crate::output::list_repository_sync_definitions_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetTemplateSyncStatusOutput {
    /// <p>The details of the last sync that's returned by Proton.</p>
    #[doc(hidden)]
    pub latest_sync: std::option::Option<crate::model::ResourceSyncAttempt>,
    /// <p>The details of the last successful sync that's returned by Proton.</p>
    #[doc(hidden)]
    pub latest_successful_sync: std::option::Option<crate::model::ResourceSyncAttempt>,
    /// <p>The template sync desired state that's returned by Proton.</p>
    #[doc(hidden)]
    pub desired_state: std::option::Option<crate::model::Revision>,
}
impl GetTemplateSyncStatusOutput {
    /// <p>The details of the last sync that's returned by Proton.</p>
    pub fn latest_sync(&self) -> std::option::Option<&crate::model::ResourceSyncAttempt> {
        self.latest_sync.as_ref()
    }
    /// <p>The details of the last successful sync that's returned by Proton.</p>
    pub fn latest_successful_sync(
        &self,
    ) -> std::option::Option<&crate::model::ResourceSyncAttempt> {
        self.latest_successful_sync.as_ref()
    }
    /// <p>The template sync desired state that's returned by Proton.</p>
    pub fn desired_state(&self) -> std::option::Option<&crate::model::Revision> {
        self.desired_state.as_ref()
    }
}
/// See [`GetTemplateSyncStatusOutput`](crate::output::GetTemplateSyncStatusOutput).
pub mod get_template_sync_status_output {

    /// A builder for [`GetTemplateSyncStatusOutput`](crate::output::GetTemplateSyncStatusOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) latest_sync: std::option::Option<crate::model::ResourceSyncAttempt>,
        pub(crate) latest_successful_sync: std::option::Option<crate::model::ResourceSyncAttempt>,
        pub(crate) desired_state: std::option::Option<crate::model::Revision>,
    }
    impl Builder {
        /// <p>The details of the last sync that's returned by Proton.</p>
        pub fn latest_sync(mut self, input: crate::model::ResourceSyncAttempt) -> Self {
            self.latest_sync = Some(input);
            self
        }
        /// <p>The details of the last sync that's returned by Proton.</p>
        pub fn set_latest_sync(
            mut self,
            input: std::option::Option<crate::model::ResourceSyncAttempt>,
        ) -> Self {
            self.latest_sync = input;
            self
        }
        /// <p>The details of the last successful sync that's returned by Proton.</p>
        pub fn latest_successful_sync(mut self, input: crate::model::ResourceSyncAttempt) -> Self {
            self.latest_successful_sync = Some(input);
            self
        }
        /// <p>The details of the last successful sync that's returned by Proton.</p>
        pub fn set_latest_successful_sync(
            mut self,
            input: std::option::Option<crate::model::ResourceSyncAttempt>,
        ) -> Self {
            self.latest_successful_sync = input;
            self
        }
        /// <p>The template sync desired state that's returned by Proton.</p>
        pub fn desired_state(mut self, input: crate::model::Revision) -> Self {
            self.desired_state = Some(input);
            self
        }
        /// <p>The template sync desired state that's returned by Proton.</p>
        pub fn set_desired_state(
            mut self,
            input: std::option::Option<crate::model::Revision>,
        ) -> Self {
            self.desired_state = input;
            self
        }
        /// Consumes the builder and constructs a [`GetTemplateSyncStatusOutput`](crate::output::GetTemplateSyncStatusOutput).
        pub fn build(self) -> crate::output::GetTemplateSyncStatusOutput {
            crate::output::GetTemplateSyncStatusOutput {
                latest_sync: self.latest_sync,
                latest_successful_sync: self.latest_successful_sync,
                desired_state: self.desired_state,
            }
        }
    }
}
impl GetTemplateSyncStatusOutput {
    /// Creates a new builder-style object to manufacture [`GetTemplateSyncStatusOutput`](crate::output::GetTemplateSyncStatusOutput).
    pub fn builder() -> crate::output::get_template_sync_status_output::Builder {
        crate::output::get_template_sync_status_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetRepositorySyncStatusOutput {
    /// <p>The repository sync status detail data that's returned by Proton.</p>
    #[doc(hidden)]
    pub latest_sync: std::option::Option<crate::model::RepositorySyncAttempt>,
}
impl GetRepositorySyncStatusOutput {
    /// <p>The repository sync status detail data that's returned by Proton.</p>
    pub fn latest_sync(&self) -> std::option::Option<&crate::model::RepositorySyncAttempt> {
        self.latest_sync.as_ref()
    }
}
/// See [`GetRepositorySyncStatusOutput`](crate::output::GetRepositorySyncStatusOutput).
pub mod get_repository_sync_status_output {

    /// A builder for [`GetRepositorySyncStatusOutput`](crate::output::GetRepositorySyncStatusOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) latest_sync: std::option::Option<crate::model::RepositorySyncAttempt>,
    }
    impl Builder {
        /// <p>The repository sync status detail data that's returned by Proton.</p>
        pub fn latest_sync(mut self, input: crate::model::RepositorySyncAttempt) -> Self {
            self.latest_sync = Some(input);
            self
        }
        /// <p>The repository sync status detail data that's returned by Proton.</p>
        pub fn set_latest_sync(
            mut self,
            input: std::option::Option<crate::model::RepositorySyncAttempt>,
        ) -> Self {
            self.latest_sync = input;
            self
        }
        /// Consumes the builder and constructs a [`GetRepositorySyncStatusOutput`](crate::output::GetRepositorySyncStatusOutput).
        pub fn build(self) -> crate::output::GetRepositorySyncStatusOutput {
            crate::output::GetRepositorySyncStatusOutput {
                latest_sync: self.latest_sync,
            }
        }
    }
}
impl GetRepositorySyncStatusOutput {
    /// Creates a new builder-style object to manufacture [`GetRepositorySyncStatusOutput`](crate::output::GetRepositorySyncStatusOutput).
    pub fn builder() -> crate::output::get_repository_sync_status_output::Builder {
        crate::output::get_repository_sync_status_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CancelServicePipelineDeploymentOutput {
    /// <p>The service pipeline detail data that's returned by Proton.</p>
    #[doc(hidden)]
    pub pipeline: std::option::Option<crate::model::ServicePipeline>,
}
impl CancelServicePipelineDeploymentOutput {
    /// <p>The service pipeline detail data that's returned by Proton.</p>
    pub fn pipeline(&self) -> std::option::Option<&crate::model::ServicePipeline> {
        self.pipeline.as_ref()
    }
}
/// See [`CancelServicePipelineDeploymentOutput`](crate::output::CancelServicePipelineDeploymentOutput).
pub mod cancel_service_pipeline_deployment_output {

    /// A builder for [`CancelServicePipelineDeploymentOutput`](crate::output::CancelServicePipelineDeploymentOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) pipeline: std::option::Option<crate::model::ServicePipeline>,
    }
    impl Builder {
        /// <p>The service pipeline detail data that's returned by Proton.</p>
        pub fn pipeline(mut self, input: crate::model::ServicePipeline) -> Self {
            self.pipeline = Some(input);
            self
        }
        /// <p>The service pipeline detail data that's returned by Proton.</p>
        pub fn set_pipeline(
            mut self,
            input: std::option::Option<crate::model::ServicePipeline>,
        ) -> Self {
            self.pipeline = input;
            self
        }
        /// Consumes the builder and constructs a [`CancelServicePipelineDeploymentOutput`](crate::output::CancelServicePipelineDeploymentOutput).
        pub fn build(self) -> crate::output::CancelServicePipelineDeploymentOutput {
            crate::output::CancelServicePipelineDeploymentOutput {
                pipeline: self.pipeline,
            }
        }
    }
}
impl CancelServicePipelineDeploymentOutput {
    /// Creates a new builder-style object to manufacture [`CancelServicePipelineDeploymentOutput`](crate::output::CancelServicePipelineDeploymentOutput).
    pub fn builder() -> crate::output::cancel_service_pipeline_deployment_output::Builder {
        crate::output::cancel_service_pipeline_deployment_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CancelServiceInstanceDeploymentOutput {
    /// <p>The service instance summary data that's returned by Proton.</p>
    #[doc(hidden)]
    pub service_instance: std::option::Option<crate::model::ServiceInstance>,
}
impl CancelServiceInstanceDeploymentOutput {
    /// <p>The service instance summary data that's returned by Proton.</p>
    pub fn service_instance(&self) -> std::option::Option<&crate::model::ServiceInstance> {
        self.service_instance.as_ref()
    }
}
/// See [`CancelServiceInstanceDeploymentOutput`](crate::output::CancelServiceInstanceDeploymentOutput).
pub mod cancel_service_instance_deployment_output {

    /// A builder for [`CancelServiceInstanceDeploymentOutput`](crate::output::CancelServiceInstanceDeploymentOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) service_instance: std::option::Option<crate::model::ServiceInstance>,
    }
    impl Builder {
        /// <p>The service instance summary data that's returned by Proton.</p>
        pub fn service_instance(mut self, input: crate::model::ServiceInstance) -> Self {
            self.service_instance = Some(input);
            self
        }
        /// <p>The service instance summary data that's returned by Proton.</p>
        pub fn set_service_instance(
            mut self,
            input: std::option::Option<crate::model::ServiceInstance>,
        ) -> Self {
            self.service_instance = input;
            self
        }
        /// Consumes the builder and constructs a [`CancelServiceInstanceDeploymentOutput`](crate::output::CancelServiceInstanceDeploymentOutput).
        pub fn build(self) -> crate::output::CancelServiceInstanceDeploymentOutput {
            crate::output::CancelServiceInstanceDeploymentOutput {
                service_instance: self.service_instance,
            }
        }
    }
}
impl CancelServiceInstanceDeploymentOutput {
    /// Creates a new builder-style object to manufacture [`CancelServiceInstanceDeploymentOutput`](crate::output::CancelServiceInstanceDeploymentOutput).
    pub fn builder() -> crate::output::cancel_service_instance_deployment_output::Builder {
        crate::output::cancel_service_instance_deployment_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CancelEnvironmentDeploymentOutput {
    /// <p>The environment summary data that's returned by Proton.</p>
    #[doc(hidden)]
    pub environment: std::option::Option<crate::model::Environment>,
}
impl CancelEnvironmentDeploymentOutput {
    /// <p>The environment summary data that's returned by Proton.</p>
    pub fn environment(&self) -> std::option::Option<&crate::model::Environment> {
        self.environment.as_ref()
    }
}
/// See [`CancelEnvironmentDeploymentOutput`](crate::output::CancelEnvironmentDeploymentOutput).
pub mod cancel_environment_deployment_output {

    /// A builder for [`CancelEnvironmentDeploymentOutput`](crate::output::CancelEnvironmentDeploymentOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) environment: std::option::Option<crate::model::Environment>,
    }
    impl Builder {
        /// <p>The environment summary data that's returned by Proton.</p>
        pub fn environment(mut self, input: crate::model::Environment) -> Self {
            self.environment = Some(input);
            self
        }
        /// <p>The environment summary data that's returned by Proton.</p>
        pub fn set_environment(
            mut self,
            input: std::option::Option<crate::model::Environment>,
        ) -> Self {
            self.environment = input;
            self
        }
        /// Consumes the builder and constructs a [`CancelEnvironmentDeploymentOutput`](crate::output::CancelEnvironmentDeploymentOutput).
        pub fn build(self) -> crate::output::CancelEnvironmentDeploymentOutput {
            crate::output::CancelEnvironmentDeploymentOutput {
                environment: self.environment,
            }
        }
    }
}
impl CancelEnvironmentDeploymentOutput {
    /// Creates a new builder-style object to manufacture [`CancelEnvironmentDeploymentOutput`](crate::output::CancelEnvironmentDeploymentOutput).
    pub fn builder() -> crate::output::cancel_environment_deployment_output::Builder {
        crate::output::cancel_environment_deployment_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CancelComponentDeploymentOutput {
    /// <p>The detailed data of the component with the deployment that is being canceled.</p>
    #[doc(hidden)]
    pub component: std::option::Option<crate::model::Component>,
}
impl CancelComponentDeploymentOutput {
    /// <p>The detailed data of the component with the deployment that is being canceled.</p>
    pub fn component(&self) -> std::option::Option<&crate::model::Component> {
        self.component.as_ref()
    }
}
/// See [`CancelComponentDeploymentOutput`](crate::output::CancelComponentDeploymentOutput).
pub mod cancel_component_deployment_output {

    /// A builder for [`CancelComponentDeploymentOutput`](crate::output::CancelComponentDeploymentOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) component: std::option::Option<crate::model::Component>,
    }
    impl Builder {
        /// <p>The detailed data of the component with the deployment that is being canceled.</p>
        pub fn component(mut self, input: crate::model::Component) -> Self {
            self.component = Some(input);
            self
        }
        /// <p>The detailed data of the component with the deployment that is being canceled.</p>
        pub fn set_component(
            mut self,
            input: std::option::Option<crate::model::Component>,
        ) -> Self {
            self.component = input;
            self
        }
        /// Consumes the builder and constructs a [`CancelComponentDeploymentOutput`](crate::output::CancelComponentDeploymentOutput).
        pub fn build(self) -> crate::output::CancelComponentDeploymentOutput {
            crate::output::CancelComponentDeploymentOutput {
                component: self.component,
            }
        }
    }
}
impl CancelComponentDeploymentOutput {
    /// Creates a new builder-style object to manufacture [`CancelComponentDeploymentOutput`](crate::output::CancelComponentDeploymentOutput).
    pub fn builder() -> crate::output::cancel_component_deployment_output::Builder {
        crate::output::cancel_component_deployment_output::Builder::default()
    }
}