aws-sdk-appsync 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 UpdateTypeOutput {
    /// <p>The updated <code>Type</code> object.</p>
    #[doc(hidden)]
    pub r#type: std::option::Option<crate::model::Type>,
}
impl UpdateTypeOutput {
    /// <p>The updated <code>Type</code> object.</p>
    pub fn r#type(&self) -> std::option::Option<&crate::model::Type> {
        self.r#type.as_ref()
    }
}
/// See [`UpdateTypeOutput`](crate::output::UpdateTypeOutput).
pub mod update_type_output {

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateResolverOutput {
    /// <p>The updated <code>Resolver</code> object.</p>
    #[doc(hidden)]
    pub resolver: std::option::Option<crate::model::Resolver>,
}
impl UpdateResolverOutput {
    /// <p>The updated <code>Resolver</code> object.</p>
    pub fn resolver(&self) -> std::option::Option<&crate::model::Resolver> {
        self.resolver.as_ref()
    }
}
/// See [`UpdateResolverOutput`](crate::output::UpdateResolverOutput).
pub mod update_resolver_output {

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateGraphqlApiOutput {
    /// <p>The updated <code>GraphqlApi</code> object.</p>
    #[doc(hidden)]
    pub graphql_api: std::option::Option<crate::model::GraphqlApi>,
}
impl UpdateGraphqlApiOutput {
    /// <p>The updated <code>GraphqlApi</code> object.</p>
    pub fn graphql_api(&self) -> std::option::Option<&crate::model::GraphqlApi> {
        self.graphql_api.as_ref()
    }
}
/// See [`UpdateGraphqlApiOutput`](crate::output::UpdateGraphqlApiOutput).
pub mod update_graphql_api_output {

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateFunctionOutput {
    /// <p>The <code>Function</code> object.</p>
    #[doc(hidden)]
    pub function_configuration: std::option::Option<crate::model::FunctionConfiguration>,
}
impl UpdateFunctionOutput {
    /// <p>The <code>Function</code> object.</p>
    pub fn function_configuration(
        &self,
    ) -> std::option::Option<&crate::model::FunctionConfiguration> {
        self.function_configuration.as_ref()
    }
}
/// See [`UpdateFunctionOutput`](crate::output::UpdateFunctionOutput).
pub mod update_function_output {

    /// A builder for [`UpdateFunctionOutput`](crate::output::UpdateFunctionOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) function_configuration: std::option::Option<crate::model::FunctionConfiguration>,
    }
    impl Builder {
        /// <p>The <code>Function</code> object.</p>
        pub fn function_configuration(
            mut self,
            input: crate::model::FunctionConfiguration,
        ) -> Self {
            self.function_configuration = Some(input);
            self
        }
        /// <p>The <code>Function</code> object.</p>
        pub fn set_function_configuration(
            mut self,
            input: std::option::Option<crate::model::FunctionConfiguration>,
        ) -> Self {
            self.function_configuration = input;
            self
        }
        /// Consumes the builder and constructs a [`UpdateFunctionOutput`](crate::output::UpdateFunctionOutput).
        pub fn build(self) -> crate::output::UpdateFunctionOutput {
            crate::output::UpdateFunctionOutput {
                function_configuration: self.function_configuration,
            }
        }
    }
}
impl UpdateFunctionOutput {
    /// Creates a new builder-style object to manufacture [`UpdateFunctionOutput`](crate::output::UpdateFunctionOutput).
    pub fn builder() -> crate::output::update_function_output::Builder {
        crate::output::update_function_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateDomainNameOutput {
    /// <p>The configuration for the <code>DomainName</code>.</p>
    #[doc(hidden)]
    pub domain_name_config: std::option::Option<crate::model::DomainNameConfig>,
}
impl UpdateDomainNameOutput {
    /// <p>The configuration for the <code>DomainName</code>.</p>
    pub fn domain_name_config(&self) -> std::option::Option<&crate::model::DomainNameConfig> {
        self.domain_name_config.as_ref()
    }
}
/// See [`UpdateDomainNameOutput`](crate::output::UpdateDomainNameOutput).
pub mod update_domain_name_output {

    /// A builder for [`UpdateDomainNameOutput`](crate::output::UpdateDomainNameOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) domain_name_config: std::option::Option<crate::model::DomainNameConfig>,
    }
    impl Builder {
        /// <p>The configuration for the <code>DomainName</code>.</p>
        pub fn domain_name_config(mut self, input: crate::model::DomainNameConfig) -> Self {
            self.domain_name_config = Some(input);
            self
        }
        /// <p>The configuration for the <code>DomainName</code>.</p>
        pub fn set_domain_name_config(
            mut self,
            input: std::option::Option<crate::model::DomainNameConfig>,
        ) -> Self {
            self.domain_name_config = input;
            self
        }
        /// Consumes the builder and constructs a [`UpdateDomainNameOutput`](crate::output::UpdateDomainNameOutput).
        pub fn build(self) -> crate::output::UpdateDomainNameOutput {
            crate::output::UpdateDomainNameOutput {
                domain_name_config: self.domain_name_config,
            }
        }
    }
}
impl UpdateDomainNameOutput {
    /// Creates a new builder-style object to manufacture [`UpdateDomainNameOutput`](crate::output::UpdateDomainNameOutput).
    pub fn builder() -> crate::output::update_domain_name_output::Builder {
        crate::output::update_domain_name_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateDataSourceOutput {
    /// <p>The updated <code>DataSource</code> object.</p>
    #[doc(hidden)]
    pub data_source: std::option::Option<crate::model::DataSource>,
}
impl UpdateDataSourceOutput {
    /// <p>The updated <code>DataSource</code> object.</p>
    pub fn data_source(&self) -> std::option::Option<&crate::model::DataSource> {
        self.data_source.as_ref()
    }
}
/// See [`UpdateDataSourceOutput`](crate::output::UpdateDataSourceOutput).
pub mod update_data_source_output {

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateApiKeyOutput {
    /// <p>The API key.</p>
    #[doc(hidden)]
    pub api_key: std::option::Option<crate::model::ApiKey>,
}
impl UpdateApiKeyOutput {
    /// <p>The API key.</p>
    pub fn api_key(&self) -> std::option::Option<&crate::model::ApiKey> {
        self.api_key.as_ref()
    }
}
/// See [`UpdateApiKeyOutput`](crate::output::UpdateApiKeyOutput).
pub mod update_api_key_output {

    /// A builder for [`UpdateApiKeyOutput`](crate::output::UpdateApiKeyOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) api_key: std::option::Option<crate::model::ApiKey>,
    }
    impl Builder {
        /// <p>The API key.</p>
        pub fn api_key(mut self, input: crate::model::ApiKey) -> Self {
            self.api_key = Some(input);
            self
        }
        /// <p>The API key.</p>
        pub fn set_api_key(mut self, input: std::option::Option<crate::model::ApiKey>) -> Self {
            self.api_key = input;
            self
        }
        /// Consumes the builder and constructs a [`UpdateApiKeyOutput`](crate::output::UpdateApiKeyOutput).
        pub fn build(self) -> crate::output::UpdateApiKeyOutput {
            crate::output::UpdateApiKeyOutput {
                api_key: self.api_key,
            }
        }
    }
}
impl UpdateApiKeyOutput {
    /// Creates a new builder-style object to manufacture [`UpdateApiKeyOutput`](crate::output::UpdateApiKeyOutput).
    pub fn builder() -> crate::output::update_api_key_output::Builder {
        crate::output::update_api_key_output::Builder::default()
    }
}

/// <p>Represents the output of a <code>UpdateApiCache</code> operation.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateApiCacheOutput {
    /// <p>The <code>ApiCache</code> object.</p>
    #[doc(hidden)]
    pub api_cache: std::option::Option<crate::model::ApiCache>,
}
impl UpdateApiCacheOutput {
    /// <p>The <code>ApiCache</code> object.</p>
    pub fn api_cache(&self) -> std::option::Option<&crate::model::ApiCache> {
        self.api_cache.as_ref()
    }
}
/// See [`UpdateApiCacheOutput`](crate::output::UpdateApiCacheOutput).
pub mod update_api_cache_output {

    /// A builder for [`UpdateApiCacheOutput`](crate::output::UpdateApiCacheOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) api_cache: std::option::Option<crate::model::ApiCache>,
    }
    impl Builder {
        /// <p>The <code>ApiCache</code> object.</p>
        pub fn api_cache(mut self, input: crate::model::ApiCache) -> Self {
            self.api_cache = Some(input);
            self
        }
        /// <p>The <code>ApiCache</code> object.</p>
        pub fn set_api_cache(mut self, input: std::option::Option<crate::model::ApiCache>) -> Self {
            self.api_cache = input;
            self
        }
        /// Consumes the builder and constructs a [`UpdateApiCacheOutput`](crate::output::UpdateApiCacheOutput).
        pub fn build(self) -> crate::output::UpdateApiCacheOutput {
            crate::output::UpdateApiCacheOutput {
                api_cache: self.api_cache,
            }
        }
    }
}
impl UpdateApiCacheOutput {
    /// Creates a new builder-style object to manufacture [`UpdateApiCacheOutput`](crate::output::UpdateApiCacheOutput).
    pub fn builder() -> crate::output::update_api_cache_output::Builder {
        crate::output::update_api_cache_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 StartSchemaCreationOutput {
    /// <p>The current state of the schema (PROCESSING, FAILED, SUCCESS, or NOT_APPLICABLE). When the schema is in the ACTIVE state, you can add data.</p>
    #[doc(hidden)]
    pub status: std::option::Option<crate::model::SchemaStatus>,
}
impl StartSchemaCreationOutput {
    /// <p>The current state of the schema (PROCESSING, FAILED, SUCCESS, or NOT_APPLICABLE). When the schema is in the ACTIVE state, you can add data.</p>
    pub fn status(&self) -> std::option::Option<&crate::model::SchemaStatus> {
        self.status.as_ref()
    }
}
/// See [`StartSchemaCreationOutput`](crate::output::StartSchemaCreationOutput).
pub mod start_schema_creation_output {

    /// A builder for [`StartSchemaCreationOutput`](crate::output::StartSchemaCreationOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) status: std::option::Option<crate::model::SchemaStatus>,
    }
    impl Builder {
        /// <p>The current state of the schema (PROCESSING, FAILED, SUCCESS, or NOT_APPLICABLE). When the schema is in the ACTIVE state, you can add data.</p>
        pub fn status(mut self, input: crate::model::SchemaStatus) -> Self {
            self.status = Some(input);
            self
        }
        /// <p>The current state of the schema (PROCESSING, FAILED, SUCCESS, or NOT_APPLICABLE). When the schema is in the ACTIVE state, you can add data.</p>
        pub fn set_status(
            mut self,
            input: std::option::Option<crate::model::SchemaStatus>,
        ) -> Self {
            self.status = input;
            self
        }
        /// Consumes the builder and constructs a [`StartSchemaCreationOutput`](crate::output::StartSchemaCreationOutput).
        pub fn build(self) -> crate::output::StartSchemaCreationOutput {
            crate::output::StartSchemaCreationOutput {
                status: self.status,
            }
        }
    }
}
impl StartSchemaCreationOutput {
    /// Creates a new builder-style object to manufacture [`StartSchemaCreationOutput`](crate::output::StartSchemaCreationOutput).
    pub fn builder() -> crate::output::start_schema_creation_output::Builder {
        crate::output::start_schema_creation_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListTypesOutput {
    /// <p>The <code>Type</code> objects.</p>
    #[doc(hidden)]
    pub types: std::option::Option<std::vec::Vec<crate::model::Type>>,
    /// <p>An identifier to pass in the next request to this operation to return the next set of items in the list.</p>
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
}
impl ListTypesOutput {
    /// <p>The <code>Type</code> objects.</p>
    pub fn types(&self) -> std::option::Option<&[crate::model::Type]> {
        self.types.as_deref()
    }
    /// <p>An identifier to pass in the next request to this operation to return the next set of items in the list.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
/// See [`ListTypesOutput`](crate::output::ListTypesOutput).
pub mod list_types_output {

    /// A builder for [`ListTypesOutput`](crate::output::ListTypesOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) types: std::option::Option<std::vec::Vec<crate::model::Type>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `types`.
        ///
        /// To override the contents of this collection use [`set_types`](Self::set_types).
        ///
        /// <p>The <code>Type</code> objects.</p>
        pub fn types(mut self, input: crate::model::Type) -> Self {
            let mut v = self.types.unwrap_or_default();
            v.push(input);
            self.types = Some(v);
            self
        }
        /// <p>The <code>Type</code> objects.</p>
        pub fn set_types(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Type>>,
        ) -> Self {
            self.types = input;
            self
        }
        /// <p>An identifier to pass in the next request to this operation to return the next set of items in the list.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>An identifier to pass in the next request to this operation to return the next set of items in the list.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`ListTypesOutput`](crate::output::ListTypesOutput).
        pub fn build(self) -> crate::output::ListTypesOutput {
            crate::output::ListTypesOutput {
                types: self.types,
                next_token: self.next_token,
            }
        }
    }
}
impl ListTypesOutput {
    /// Creates a new builder-style object to manufacture [`ListTypesOutput`](crate::output::ListTypesOutput).
    pub fn builder() -> crate::output::list_types_output::Builder {
        crate::output::list_types_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 <code>TagMap</code> object.</p>
    #[doc(hidden)]
    pub tags:
        std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl ListTagsForResourceOutput {
    /// <p>A <code>TagMap</code> object.</p>
    pub fn tags(
        &self,
    ) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
    {
        self.tags.as_ref()
    }
}
/// 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::collections::HashMap<std::string::String, std::string::String>,
        >,
    }
    impl Builder {
        /// Adds a key-value pair to `tags`.
        ///
        /// To override the contents of this collection use [`set_tags`](Self::set_tags).
        ///
        /// <p>A <code>TagMap</code> object.</p>
        pub fn tags(
            mut self,
            k: impl Into<std::string::String>,
            v: impl Into<std::string::String>,
        ) -> Self {
            let mut hash_map = self.tags.unwrap_or_default();
            hash_map.insert(k.into(), v.into());
            self.tags = Some(hash_map);
            self
        }
        /// <p>A <code>TagMap</code> object.</p>
        pub fn set_tags(
            mut self,
            input: std::option::Option<
                std::collections::HashMap<std::string::String, std::string::String>,
            >,
        ) -> Self {
            self.tags = input;
            self
        }
        /// Consumes the builder and constructs a [`ListTagsForResourceOutput`](crate::output::ListTagsForResourceOutput).
        pub fn build(self) -> crate::output::ListTagsForResourceOutput {
            crate::output::ListTagsForResourceOutput { tags: self.tags }
        }
    }
}
impl ListTagsForResourceOutput {
    /// Creates a new builder-style object to manufacture [`ListTagsForResourceOutput`](crate::output::ListTagsForResourceOutput).
    pub fn builder() -> crate::output::list_tags_for_resource_output::Builder {
        crate::output::list_tags_for_resource_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListResolversByFunctionOutput {
    /// <p>The list of resolvers.</p>
    #[doc(hidden)]
    pub resolvers: std::option::Option<std::vec::Vec<crate::model::Resolver>>,
    /// <p>An identifier that you can use to return the next set of items in the list.</p>
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
}
impl ListResolversByFunctionOutput {
    /// <p>The list of resolvers.</p>
    pub fn resolvers(&self) -> std::option::Option<&[crate::model::Resolver]> {
        self.resolvers.as_deref()
    }
    /// <p>An identifier that you can use to return the next set of items in the list.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
/// See [`ListResolversByFunctionOutput`](crate::output::ListResolversByFunctionOutput).
pub mod list_resolvers_by_function_output {

    /// A builder for [`ListResolversByFunctionOutput`](crate::output::ListResolversByFunctionOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) resolvers: std::option::Option<std::vec::Vec<crate::model::Resolver>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `resolvers`.
        ///
        /// To override the contents of this collection use [`set_resolvers`](Self::set_resolvers).
        ///
        /// <p>The list of resolvers.</p>
        pub fn resolvers(mut self, input: crate::model::Resolver) -> Self {
            let mut v = self.resolvers.unwrap_or_default();
            v.push(input);
            self.resolvers = Some(v);
            self
        }
        /// <p>The list of resolvers.</p>
        pub fn set_resolvers(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Resolver>>,
        ) -> Self {
            self.resolvers = input;
            self
        }
        /// <p>An identifier that you can use to return the next set of items in the list.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>An identifier that you can use to return the next set of items in the list.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`ListResolversByFunctionOutput`](crate::output::ListResolversByFunctionOutput).
        pub fn build(self) -> crate::output::ListResolversByFunctionOutput {
            crate::output::ListResolversByFunctionOutput {
                resolvers: self.resolvers,
                next_token: self.next_token,
            }
        }
    }
}
impl ListResolversByFunctionOutput {
    /// Creates a new builder-style object to manufacture [`ListResolversByFunctionOutput`](crate::output::ListResolversByFunctionOutput).
    pub fn builder() -> crate::output::list_resolvers_by_function_output::Builder {
        crate::output::list_resolvers_by_function_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListResolversOutput {
    /// <p>The <code>Resolver</code> objects.</p>
    #[doc(hidden)]
    pub resolvers: std::option::Option<std::vec::Vec<crate::model::Resolver>>,
    /// <p>An identifier to pass in the next request to this operation to return the next set of items in the list.</p>
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
}
impl ListResolversOutput {
    /// <p>The <code>Resolver</code> objects.</p>
    pub fn resolvers(&self) -> std::option::Option<&[crate::model::Resolver]> {
        self.resolvers.as_deref()
    }
    /// <p>An identifier to pass in the next request to this operation to return the next set of items in the list.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
/// See [`ListResolversOutput`](crate::output::ListResolversOutput).
pub mod list_resolvers_output {

    /// A builder for [`ListResolversOutput`](crate::output::ListResolversOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) resolvers: std::option::Option<std::vec::Vec<crate::model::Resolver>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `resolvers`.
        ///
        /// To override the contents of this collection use [`set_resolvers`](Self::set_resolvers).
        ///
        /// <p>The <code>Resolver</code> objects.</p>
        pub fn resolvers(mut self, input: crate::model::Resolver) -> Self {
            let mut v = self.resolvers.unwrap_or_default();
            v.push(input);
            self.resolvers = Some(v);
            self
        }
        /// <p>The <code>Resolver</code> objects.</p>
        pub fn set_resolvers(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Resolver>>,
        ) -> Self {
            self.resolvers = input;
            self
        }
        /// <p>An identifier to pass in the next request to this operation to return the next set of items in the list.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>An identifier to pass in the next request to this operation to return the next set of items in the list.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`ListResolversOutput`](crate::output::ListResolversOutput).
        pub fn build(self) -> crate::output::ListResolversOutput {
            crate::output::ListResolversOutput {
                resolvers: self.resolvers,
                next_token: self.next_token,
            }
        }
    }
}
impl ListResolversOutput {
    /// Creates a new builder-style object to manufacture [`ListResolversOutput`](crate::output::ListResolversOutput).
    pub fn builder() -> crate::output::list_resolvers_output::Builder {
        crate::output::list_resolvers_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListGraphqlApisOutput {
    /// <p>The <code>GraphqlApi</code> objects.</p>
    #[doc(hidden)]
    pub graphql_apis: std::option::Option<std::vec::Vec<crate::model::GraphqlApi>>,
    /// <p>An identifier to pass in the next request to this operation to return the next set of items in the list.</p>
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
}
impl ListGraphqlApisOutput {
    /// <p>The <code>GraphqlApi</code> objects.</p>
    pub fn graphql_apis(&self) -> std::option::Option<&[crate::model::GraphqlApi]> {
        self.graphql_apis.as_deref()
    }
    /// <p>An identifier to pass in the next request to this operation to return the next set of items in the list.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
/// See [`ListGraphqlApisOutput`](crate::output::ListGraphqlApisOutput).
pub mod list_graphql_apis_output {

    /// A builder for [`ListGraphqlApisOutput`](crate::output::ListGraphqlApisOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) graphql_apis: std::option::Option<std::vec::Vec<crate::model::GraphqlApi>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `graphql_apis`.
        ///
        /// To override the contents of this collection use [`set_graphql_apis`](Self::set_graphql_apis).
        ///
        /// <p>The <code>GraphqlApi</code> objects.</p>
        pub fn graphql_apis(mut self, input: crate::model::GraphqlApi) -> Self {
            let mut v = self.graphql_apis.unwrap_or_default();
            v.push(input);
            self.graphql_apis = Some(v);
            self
        }
        /// <p>The <code>GraphqlApi</code> objects.</p>
        pub fn set_graphql_apis(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::GraphqlApi>>,
        ) -> Self {
            self.graphql_apis = input;
            self
        }
        /// <p>An identifier to pass in the next request to this operation to return the next set of items in the list.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>An identifier to pass in the next request to this operation to return the next set of items in the list.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`ListGraphqlApisOutput`](crate::output::ListGraphqlApisOutput).
        pub fn build(self) -> crate::output::ListGraphqlApisOutput {
            crate::output::ListGraphqlApisOutput {
                graphql_apis: self.graphql_apis,
                next_token: self.next_token,
            }
        }
    }
}
impl ListGraphqlApisOutput {
    /// Creates a new builder-style object to manufacture [`ListGraphqlApisOutput`](crate::output::ListGraphqlApisOutput).
    pub fn builder() -> crate::output::list_graphql_apis_output::Builder {
        crate::output::list_graphql_apis_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListFunctionsOutput {
    /// <p>A list of <code>Function</code> objects.</p>
    #[doc(hidden)]
    pub functions: std::option::Option<std::vec::Vec<crate::model::FunctionConfiguration>>,
    /// <p>An identifier that was returned from the previous call to this operation, which you can use to return the next set of items in the list.</p>
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
}
impl ListFunctionsOutput {
    /// <p>A list of <code>Function</code> objects.</p>
    pub fn functions(&self) -> std::option::Option<&[crate::model::FunctionConfiguration]> {
        self.functions.as_deref()
    }
    /// <p>An identifier that was returned from the previous call to this operation, which you can use to return the next set of items in the list.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
/// See [`ListFunctionsOutput`](crate::output::ListFunctionsOutput).
pub mod list_functions_output {

    /// A builder for [`ListFunctionsOutput`](crate::output::ListFunctionsOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) functions:
            std::option::Option<std::vec::Vec<crate::model::FunctionConfiguration>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `functions`.
        ///
        /// To override the contents of this collection use [`set_functions`](Self::set_functions).
        ///
        /// <p>A list of <code>Function</code> objects.</p>
        pub fn functions(mut self, input: crate::model::FunctionConfiguration) -> Self {
            let mut v = self.functions.unwrap_or_default();
            v.push(input);
            self.functions = Some(v);
            self
        }
        /// <p>A list of <code>Function</code> objects.</p>
        pub fn set_functions(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::FunctionConfiguration>>,
        ) -> Self {
            self.functions = input;
            self
        }
        /// <p>An identifier that was returned from the previous call to this operation, which you can use to return the next set of items in the list.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>An identifier that was returned from the previous call to this operation, which you can use to return the next set of items in the list.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`ListFunctionsOutput`](crate::output::ListFunctionsOutput).
        pub fn build(self) -> crate::output::ListFunctionsOutput {
            crate::output::ListFunctionsOutput {
                functions: self.functions,
                next_token: self.next_token,
            }
        }
    }
}
impl ListFunctionsOutput {
    /// Creates a new builder-style object to manufacture [`ListFunctionsOutput`](crate::output::ListFunctionsOutput).
    pub fn builder() -> crate::output::list_functions_output::Builder {
        crate::output::list_functions_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListDomainNamesOutput {
    /// <p>Lists configurations for multiple domain names.</p>
    #[doc(hidden)]
    pub domain_name_configs: std::option::Option<std::vec::Vec<crate::model::DomainNameConfig>>,
    /// <p>The API token.</p>
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
}
impl ListDomainNamesOutput {
    /// <p>Lists configurations for multiple domain names.</p>
    pub fn domain_name_configs(&self) -> std::option::Option<&[crate::model::DomainNameConfig]> {
        self.domain_name_configs.as_deref()
    }
    /// <p>The API token.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
/// See [`ListDomainNamesOutput`](crate::output::ListDomainNamesOutput).
pub mod list_domain_names_output {

    /// A builder for [`ListDomainNamesOutput`](crate::output::ListDomainNamesOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) domain_name_configs:
            std::option::Option<std::vec::Vec<crate::model::DomainNameConfig>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `domain_name_configs`.
        ///
        /// To override the contents of this collection use [`set_domain_name_configs`](Self::set_domain_name_configs).
        ///
        /// <p>Lists configurations for multiple domain names.</p>
        pub fn domain_name_configs(mut self, input: crate::model::DomainNameConfig) -> Self {
            let mut v = self.domain_name_configs.unwrap_or_default();
            v.push(input);
            self.domain_name_configs = Some(v);
            self
        }
        /// <p>Lists configurations for multiple domain names.</p>
        pub fn set_domain_name_configs(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::DomainNameConfig>>,
        ) -> Self {
            self.domain_name_configs = input;
            self
        }
        /// <p>The API token.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The API token.</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 [`ListDomainNamesOutput`](crate::output::ListDomainNamesOutput).
        pub fn build(self) -> crate::output::ListDomainNamesOutput {
            crate::output::ListDomainNamesOutput {
                domain_name_configs: self.domain_name_configs,
                next_token: self.next_token,
            }
        }
    }
}
impl ListDomainNamesOutput {
    /// Creates a new builder-style object to manufacture [`ListDomainNamesOutput`](crate::output::ListDomainNamesOutput).
    pub fn builder() -> crate::output::list_domain_names_output::Builder {
        crate::output::list_domain_names_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListDataSourcesOutput {
    /// <p>The <code>DataSource</code> objects.</p>
    #[doc(hidden)]
    pub data_sources: std::option::Option<std::vec::Vec<crate::model::DataSource>>,
    /// <p>An identifier to pass in the next request to this operation to return the next set of items in the list.</p>
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
}
impl ListDataSourcesOutput {
    /// <p>The <code>DataSource</code> objects.</p>
    pub fn data_sources(&self) -> std::option::Option<&[crate::model::DataSource]> {
        self.data_sources.as_deref()
    }
    /// <p>An identifier to pass in the next request to this operation to return the next set of items in the list.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
/// See [`ListDataSourcesOutput`](crate::output::ListDataSourcesOutput).
pub mod list_data_sources_output {

    /// A builder for [`ListDataSourcesOutput`](crate::output::ListDataSourcesOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) data_sources: std::option::Option<std::vec::Vec<crate::model::DataSource>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `data_sources`.
        ///
        /// To override the contents of this collection use [`set_data_sources`](Self::set_data_sources).
        ///
        /// <p>The <code>DataSource</code> objects.</p>
        pub fn data_sources(mut self, input: crate::model::DataSource) -> Self {
            let mut v = self.data_sources.unwrap_or_default();
            v.push(input);
            self.data_sources = Some(v);
            self
        }
        /// <p>The <code>DataSource</code> objects.</p>
        pub fn set_data_sources(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::DataSource>>,
        ) -> Self {
            self.data_sources = input;
            self
        }
        /// <p>An identifier to pass in the next request to this operation to return the next set of items in the list.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>An identifier to pass in the next request to this operation to return the next set of items in the list.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`ListDataSourcesOutput`](crate::output::ListDataSourcesOutput).
        pub fn build(self) -> crate::output::ListDataSourcesOutput {
            crate::output::ListDataSourcesOutput {
                data_sources: self.data_sources,
                next_token: self.next_token,
            }
        }
    }
}
impl ListDataSourcesOutput {
    /// Creates a new builder-style object to manufacture [`ListDataSourcesOutput`](crate::output::ListDataSourcesOutput).
    pub fn builder() -> crate::output::list_data_sources_output::Builder {
        crate::output::list_data_sources_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListApiKeysOutput {
    /// <p>The <code>ApiKey</code> objects.</p>
    #[doc(hidden)]
    pub api_keys: std::option::Option<std::vec::Vec<crate::model::ApiKey>>,
    /// <p>An identifier to pass in the next request to this operation to return the next set of items in the list.</p>
    #[doc(hidden)]
    pub next_token: std::option::Option<std::string::String>,
}
impl ListApiKeysOutput {
    /// <p>The <code>ApiKey</code> objects.</p>
    pub fn api_keys(&self) -> std::option::Option<&[crate::model::ApiKey]> {
        self.api_keys.as_deref()
    }
    /// <p>An identifier to pass in the next request to this operation to return the next set of items in the list.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
/// See [`ListApiKeysOutput`](crate::output::ListApiKeysOutput).
pub mod list_api_keys_output {

    /// A builder for [`ListApiKeysOutput`](crate::output::ListApiKeysOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) api_keys: std::option::Option<std::vec::Vec<crate::model::ApiKey>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `api_keys`.
        ///
        /// To override the contents of this collection use [`set_api_keys`](Self::set_api_keys).
        ///
        /// <p>The <code>ApiKey</code> objects.</p>
        pub fn api_keys(mut self, input: crate::model::ApiKey) -> Self {
            let mut v = self.api_keys.unwrap_or_default();
            v.push(input);
            self.api_keys = Some(v);
            self
        }
        /// <p>The <code>ApiKey</code> objects.</p>
        pub fn set_api_keys(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ApiKey>>,
        ) -> Self {
            self.api_keys = input;
            self
        }
        /// <p>An identifier to pass in the next request to this operation to return the next set of items in the list.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>An identifier to pass in the next request to this operation to return the next set of items in the list.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`ListApiKeysOutput`](crate::output::ListApiKeysOutput).
        pub fn build(self) -> crate::output::ListApiKeysOutput {
            crate::output::ListApiKeysOutput {
                api_keys: self.api_keys,
                next_token: self.next_token,
            }
        }
    }
}
impl ListApiKeysOutput {
    /// Creates a new builder-style object to manufacture [`ListApiKeysOutput`](crate::output::ListApiKeysOutput).
    pub fn builder() -> crate::output::list_api_keys_output::Builder {
        crate::output::list_api_keys_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetTypeOutput {
    /// <p>The <code>Type</code> object.</p>
    #[doc(hidden)]
    pub r#type: std::option::Option<crate::model::Type>,
}
impl GetTypeOutput {
    /// <p>The <code>Type</code> object.</p>
    pub fn r#type(&self) -> std::option::Option<&crate::model::Type> {
        self.r#type.as_ref()
    }
}
/// See [`GetTypeOutput`](crate::output::GetTypeOutput).
pub mod get_type_output {

    /// A builder for [`GetTypeOutput`](crate::output::GetTypeOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) r#type: std::option::Option<crate::model::Type>,
    }
    impl Builder {
        /// <p>The <code>Type</code> object.</p>
        pub fn r#type(mut self, input: crate::model::Type) -> Self {
            self.r#type = Some(input);
            self
        }
        /// <p>The <code>Type</code> object.</p>
        pub fn set_type(mut self, input: std::option::Option<crate::model::Type>) -> Self {
            self.r#type = input;
            self
        }
        /// Consumes the builder and constructs a [`GetTypeOutput`](crate::output::GetTypeOutput).
        pub fn build(self) -> crate::output::GetTypeOutput {
            crate::output::GetTypeOutput {
                r#type: self.r#type,
            }
        }
    }
}
impl GetTypeOutput {
    /// Creates a new builder-style object to manufacture [`GetTypeOutput`](crate::output::GetTypeOutput).
    pub fn builder() -> crate::output::get_type_output::Builder {
        crate::output::get_type_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetSchemaCreationStatusOutput {
    /// <p>The current state of the schema (PROCESSING, FAILED, SUCCESS, or NOT_APPLICABLE). When the schema is in the ACTIVE state, you can add data.</p>
    #[doc(hidden)]
    pub status: std::option::Option<crate::model::SchemaStatus>,
    /// <p>Detailed information about the status of the schema creation operation.</p>
    #[doc(hidden)]
    pub details: std::option::Option<std::string::String>,
}
impl GetSchemaCreationStatusOutput {
    /// <p>The current state of the schema (PROCESSING, FAILED, SUCCESS, or NOT_APPLICABLE). When the schema is in the ACTIVE state, you can add data.</p>
    pub fn status(&self) -> std::option::Option<&crate::model::SchemaStatus> {
        self.status.as_ref()
    }
    /// <p>Detailed information about the status of the schema creation operation.</p>
    pub fn details(&self) -> std::option::Option<&str> {
        self.details.as_deref()
    }
}
/// See [`GetSchemaCreationStatusOutput`](crate::output::GetSchemaCreationStatusOutput).
pub mod get_schema_creation_status_output {

    /// A builder for [`GetSchemaCreationStatusOutput`](crate::output::GetSchemaCreationStatusOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) status: std::option::Option<crate::model::SchemaStatus>,
        pub(crate) details: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The current state of the schema (PROCESSING, FAILED, SUCCESS, or NOT_APPLICABLE). When the schema is in the ACTIVE state, you can add data.</p>
        pub fn status(mut self, input: crate::model::SchemaStatus) -> Self {
            self.status = Some(input);
            self
        }
        /// <p>The current state of the schema (PROCESSING, FAILED, SUCCESS, or NOT_APPLICABLE). When the schema is in the ACTIVE state, you can add data.</p>
        pub fn set_status(
            mut self,
            input: std::option::Option<crate::model::SchemaStatus>,
        ) -> Self {
            self.status = input;
            self
        }
        /// <p>Detailed information about the status of the schema creation operation.</p>
        pub fn details(mut self, input: impl Into<std::string::String>) -> Self {
            self.details = Some(input.into());
            self
        }
        /// <p>Detailed information about the status of the schema creation operation.</p>
        pub fn set_details(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.details = input;
            self
        }
        /// Consumes the builder and constructs a [`GetSchemaCreationStatusOutput`](crate::output::GetSchemaCreationStatusOutput).
        pub fn build(self) -> crate::output::GetSchemaCreationStatusOutput {
            crate::output::GetSchemaCreationStatusOutput {
                status: self.status,
                details: self.details,
            }
        }
    }
}
impl GetSchemaCreationStatusOutput {
    /// Creates a new builder-style object to manufacture [`GetSchemaCreationStatusOutput`](crate::output::GetSchemaCreationStatusOutput).
    pub fn builder() -> crate::output::get_schema_creation_status_output::Builder {
        crate::output::get_schema_creation_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 GetResolverOutput {
    /// <p>The <code>Resolver</code> object.</p>
    #[doc(hidden)]
    pub resolver: std::option::Option<crate::model::Resolver>,
}
impl GetResolverOutput {
    /// <p>The <code>Resolver</code> object.</p>
    pub fn resolver(&self) -> std::option::Option<&crate::model::Resolver> {
        self.resolver.as_ref()
    }
}
/// See [`GetResolverOutput`](crate::output::GetResolverOutput).
pub mod get_resolver_output {

    /// A builder for [`GetResolverOutput`](crate::output::GetResolverOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) resolver: std::option::Option<crate::model::Resolver>,
    }
    impl Builder {
        /// <p>The <code>Resolver</code> object.</p>
        pub fn resolver(mut self, input: crate::model::Resolver) -> Self {
            self.resolver = Some(input);
            self
        }
        /// <p>The <code>Resolver</code> object.</p>
        pub fn set_resolver(mut self, input: std::option::Option<crate::model::Resolver>) -> Self {
            self.resolver = input;
            self
        }
        /// Consumes the builder and constructs a [`GetResolverOutput`](crate::output::GetResolverOutput).
        pub fn build(self) -> crate::output::GetResolverOutput {
            crate::output::GetResolverOutput {
                resolver: self.resolver,
            }
        }
    }
}
impl GetResolverOutput {
    /// Creates a new builder-style object to manufacture [`GetResolverOutput`](crate::output::GetResolverOutput).
    pub fn builder() -> crate::output::get_resolver_output::Builder {
        crate::output::get_resolver_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetIntrospectionSchemaOutput {
    /// <p>The schema, in GraphQL Schema Definition Language (SDL) format.</p>
    /// <p>For more information, see the <a href="http://graphql.org/learn/schema/">GraphQL SDL documentation</a>.</p>
    #[doc(hidden)]
    pub schema: std::option::Option<aws_smithy_types::Blob>,
}
impl GetIntrospectionSchemaOutput {
    /// <p>The schema, in GraphQL Schema Definition Language (SDL) format.</p>
    /// <p>For more information, see the <a href="http://graphql.org/learn/schema/">GraphQL SDL documentation</a>.</p>
    pub fn schema(&self) -> std::option::Option<&aws_smithy_types::Blob> {
        self.schema.as_ref()
    }
}
/// See [`GetIntrospectionSchemaOutput`](crate::output::GetIntrospectionSchemaOutput).
pub mod get_introspection_schema_output {

    /// A builder for [`GetIntrospectionSchemaOutput`](crate::output::GetIntrospectionSchemaOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) schema: std::option::Option<aws_smithy_types::Blob>,
    }
    impl Builder {
        /// <p>The schema, in GraphQL Schema Definition Language (SDL) format.</p>
        /// <p>For more information, see the <a href="http://graphql.org/learn/schema/">GraphQL SDL documentation</a>.</p>
        pub fn schema(mut self, input: aws_smithy_types::Blob) -> Self {
            self.schema = Some(input);
            self
        }
        /// <p>The schema, in GraphQL Schema Definition Language (SDL) format.</p>
        /// <p>For more information, see the <a href="http://graphql.org/learn/schema/">GraphQL SDL documentation</a>.</p>
        pub fn set_schema(mut self, input: std::option::Option<aws_smithy_types::Blob>) -> Self {
            self.schema = input;
            self
        }
        /// Consumes the builder and constructs a [`GetIntrospectionSchemaOutput`](crate::output::GetIntrospectionSchemaOutput).
        pub fn build(self) -> crate::output::GetIntrospectionSchemaOutput {
            crate::output::GetIntrospectionSchemaOutput {
                schema: self.schema,
            }
        }
    }
}
impl GetIntrospectionSchemaOutput {
    /// Creates a new builder-style object to manufacture [`GetIntrospectionSchemaOutput`](crate::output::GetIntrospectionSchemaOutput).
    pub fn builder() -> crate::output::get_introspection_schema_output::Builder {
        crate::output::get_introspection_schema_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetGraphqlApiOutput {
    /// <p>The <code>GraphqlApi</code> object.</p>
    #[doc(hidden)]
    pub graphql_api: std::option::Option<crate::model::GraphqlApi>,
}
impl GetGraphqlApiOutput {
    /// <p>The <code>GraphqlApi</code> object.</p>
    pub fn graphql_api(&self) -> std::option::Option<&crate::model::GraphqlApi> {
        self.graphql_api.as_ref()
    }
}
/// See [`GetGraphqlApiOutput`](crate::output::GetGraphqlApiOutput).
pub mod get_graphql_api_output {

    /// A builder for [`GetGraphqlApiOutput`](crate::output::GetGraphqlApiOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) graphql_api: std::option::Option<crate::model::GraphqlApi>,
    }
    impl Builder {
        /// <p>The <code>GraphqlApi</code> object.</p>
        pub fn graphql_api(mut self, input: crate::model::GraphqlApi) -> Self {
            self.graphql_api = Some(input);
            self
        }
        /// <p>The <code>GraphqlApi</code> object.</p>
        pub fn set_graphql_api(
            mut self,
            input: std::option::Option<crate::model::GraphqlApi>,
        ) -> Self {
            self.graphql_api = input;
            self
        }
        /// Consumes the builder and constructs a [`GetGraphqlApiOutput`](crate::output::GetGraphqlApiOutput).
        pub fn build(self) -> crate::output::GetGraphqlApiOutput {
            crate::output::GetGraphqlApiOutput {
                graphql_api: self.graphql_api,
            }
        }
    }
}
impl GetGraphqlApiOutput {
    /// Creates a new builder-style object to manufacture [`GetGraphqlApiOutput`](crate::output::GetGraphqlApiOutput).
    pub fn builder() -> crate::output::get_graphql_api_output::Builder {
        crate::output::get_graphql_api_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetFunctionOutput {
    /// <p>The <code>Function</code> object.</p>
    #[doc(hidden)]
    pub function_configuration: std::option::Option<crate::model::FunctionConfiguration>,
}
impl GetFunctionOutput {
    /// <p>The <code>Function</code> object.</p>
    pub fn function_configuration(
        &self,
    ) -> std::option::Option<&crate::model::FunctionConfiguration> {
        self.function_configuration.as_ref()
    }
}
/// See [`GetFunctionOutput`](crate::output::GetFunctionOutput).
pub mod get_function_output {

    /// A builder for [`GetFunctionOutput`](crate::output::GetFunctionOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) function_configuration: std::option::Option<crate::model::FunctionConfiguration>,
    }
    impl Builder {
        /// <p>The <code>Function</code> object.</p>
        pub fn function_configuration(
            mut self,
            input: crate::model::FunctionConfiguration,
        ) -> Self {
            self.function_configuration = Some(input);
            self
        }
        /// <p>The <code>Function</code> object.</p>
        pub fn set_function_configuration(
            mut self,
            input: std::option::Option<crate::model::FunctionConfiguration>,
        ) -> Self {
            self.function_configuration = input;
            self
        }
        /// Consumes the builder and constructs a [`GetFunctionOutput`](crate::output::GetFunctionOutput).
        pub fn build(self) -> crate::output::GetFunctionOutput {
            crate::output::GetFunctionOutput {
                function_configuration: self.function_configuration,
            }
        }
    }
}
impl GetFunctionOutput {
    /// Creates a new builder-style object to manufacture [`GetFunctionOutput`](crate::output::GetFunctionOutput).
    pub fn builder() -> crate::output::get_function_output::Builder {
        crate::output::get_function_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetDomainNameOutput {
    /// <p>The configuration for the <code>DomainName</code>.</p>
    #[doc(hidden)]
    pub domain_name_config: std::option::Option<crate::model::DomainNameConfig>,
}
impl GetDomainNameOutput {
    /// <p>The configuration for the <code>DomainName</code>.</p>
    pub fn domain_name_config(&self) -> std::option::Option<&crate::model::DomainNameConfig> {
        self.domain_name_config.as_ref()
    }
}
/// See [`GetDomainNameOutput`](crate::output::GetDomainNameOutput).
pub mod get_domain_name_output {

    /// A builder for [`GetDomainNameOutput`](crate::output::GetDomainNameOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) domain_name_config: std::option::Option<crate::model::DomainNameConfig>,
    }
    impl Builder {
        /// <p>The configuration for the <code>DomainName</code>.</p>
        pub fn domain_name_config(mut self, input: crate::model::DomainNameConfig) -> Self {
            self.domain_name_config = Some(input);
            self
        }
        /// <p>The configuration for the <code>DomainName</code>.</p>
        pub fn set_domain_name_config(
            mut self,
            input: std::option::Option<crate::model::DomainNameConfig>,
        ) -> Self {
            self.domain_name_config = input;
            self
        }
        /// Consumes the builder and constructs a [`GetDomainNameOutput`](crate::output::GetDomainNameOutput).
        pub fn build(self) -> crate::output::GetDomainNameOutput {
            crate::output::GetDomainNameOutput {
                domain_name_config: self.domain_name_config,
            }
        }
    }
}
impl GetDomainNameOutput {
    /// Creates a new builder-style object to manufacture [`GetDomainNameOutput`](crate::output::GetDomainNameOutput).
    pub fn builder() -> crate::output::get_domain_name_output::Builder {
        crate::output::get_domain_name_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetDataSourceOutput {
    /// <p>The <code>DataSource</code> object.</p>
    #[doc(hidden)]
    pub data_source: std::option::Option<crate::model::DataSource>,
}
impl GetDataSourceOutput {
    /// <p>The <code>DataSource</code> object.</p>
    pub fn data_source(&self) -> std::option::Option<&crate::model::DataSource> {
        self.data_source.as_ref()
    }
}
/// See [`GetDataSourceOutput`](crate::output::GetDataSourceOutput).
pub mod get_data_source_output {

    /// A builder for [`GetDataSourceOutput`](crate::output::GetDataSourceOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) data_source: std::option::Option<crate::model::DataSource>,
    }
    impl Builder {
        /// <p>The <code>DataSource</code> object.</p>
        pub fn data_source(mut self, input: crate::model::DataSource) -> Self {
            self.data_source = Some(input);
            self
        }
        /// <p>The <code>DataSource</code> object.</p>
        pub fn set_data_source(
            mut self,
            input: std::option::Option<crate::model::DataSource>,
        ) -> Self {
            self.data_source = input;
            self
        }
        /// Consumes the builder and constructs a [`GetDataSourceOutput`](crate::output::GetDataSourceOutput).
        pub fn build(self) -> crate::output::GetDataSourceOutput {
            crate::output::GetDataSourceOutput {
                data_source: self.data_source,
            }
        }
    }
}
impl GetDataSourceOutput {
    /// Creates a new builder-style object to manufacture [`GetDataSourceOutput`](crate::output::GetDataSourceOutput).
    pub fn builder() -> crate::output::get_data_source_output::Builder {
        crate::output::get_data_source_output::Builder::default()
    }
}

/// <p>Represents the output of a <code>GetApiCache</code> operation.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetApiCacheOutput {
    /// <p>The <code>ApiCache</code> object.</p>
    #[doc(hidden)]
    pub api_cache: std::option::Option<crate::model::ApiCache>,
}
impl GetApiCacheOutput {
    /// <p>The <code>ApiCache</code> object.</p>
    pub fn api_cache(&self) -> std::option::Option<&crate::model::ApiCache> {
        self.api_cache.as_ref()
    }
}
/// See [`GetApiCacheOutput`](crate::output::GetApiCacheOutput).
pub mod get_api_cache_output {

    /// A builder for [`GetApiCacheOutput`](crate::output::GetApiCacheOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) api_cache: std::option::Option<crate::model::ApiCache>,
    }
    impl Builder {
        /// <p>The <code>ApiCache</code> object.</p>
        pub fn api_cache(mut self, input: crate::model::ApiCache) -> Self {
            self.api_cache = Some(input);
            self
        }
        /// <p>The <code>ApiCache</code> object.</p>
        pub fn set_api_cache(mut self, input: std::option::Option<crate::model::ApiCache>) -> Self {
            self.api_cache = input;
            self
        }
        /// Consumes the builder and constructs a [`GetApiCacheOutput`](crate::output::GetApiCacheOutput).
        pub fn build(self) -> crate::output::GetApiCacheOutput {
            crate::output::GetApiCacheOutput {
                api_cache: self.api_cache,
            }
        }
    }
}
impl GetApiCacheOutput {
    /// Creates a new builder-style object to manufacture [`GetApiCacheOutput`](crate::output::GetApiCacheOutput).
    pub fn builder() -> crate::output::get_api_cache_output::Builder {
        crate::output::get_api_cache_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetApiAssociationOutput {
    /// <p>The <code>ApiAssociation</code> object.</p>
    #[doc(hidden)]
    pub api_association: std::option::Option<crate::model::ApiAssociation>,
}
impl GetApiAssociationOutput {
    /// <p>The <code>ApiAssociation</code> object.</p>
    pub fn api_association(&self) -> std::option::Option<&crate::model::ApiAssociation> {
        self.api_association.as_ref()
    }
}
/// See [`GetApiAssociationOutput`](crate::output::GetApiAssociationOutput).
pub mod get_api_association_output {

    /// A builder for [`GetApiAssociationOutput`](crate::output::GetApiAssociationOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) api_association: std::option::Option<crate::model::ApiAssociation>,
    }
    impl Builder {
        /// <p>The <code>ApiAssociation</code> object.</p>
        pub fn api_association(mut self, input: crate::model::ApiAssociation) -> Self {
            self.api_association = Some(input);
            self
        }
        /// <p>The <code>ApiAssociation</code> object.</p>
        pub fn set_api_association(
            mut self,
            input: std::option::Option<crate::model::ApiAssociation>,
        ) -> Self {
            self.api_association = input;
            self
        }
        /// Consumes the builder and constructs a [`GetApiAssociationOutput`](crate::output::GetApiAssociationOutput).
        pub fn build(self) -> crate::output::GetApiAssociationOutput {
            crate::output::GetApiAssociationOutput {
                api_association: self.api_association,
            }
        }
    }
}
impl GetApiAssociationOutput {
    /// Creates a new builder-style object to manufacture [`GetApiAssociationOutput`](crate::output::GetApiAssociationOutput).
    pub fn builder() -> crate::output::get_api_association_output::Builder {
        crate::output::get_api_association_output::Builder::default()
    }
}

/// <p>Represents the output of a <code>FlushApiCache</code> operation.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct FlushApiCacheOutput {}
/// See [`FlushApiCacheOutput`](crate::output::FlushApiCacheOutput).
pub mod flush_api_cache_output {

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct EvaluateMappingTemplateOutput {
    /// <p>The mapping template; this can be a request or response template.</p>
    #[doc(hidden)]
    pub evaluation_result: std::option::Option<std::string::String>,
    /// <p>The <code>ErrorDetail</code> object.</p>
    #[doc(hidden)]
    pub error: std::option::Option<crate::model::ErrorDetail>,
    /// <p>A list of logs that were generated by calls to <code>util.log.info</code> and <code>util.log.error</code> in the evaluated code.</p>
    #[doc(hidden)]
    pub logs: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl EvaluateMappingTemplateOutput {
    /// <p>The mapping template; this can be a request or response template.</p>
    pub fn evaluation_result(&self) -> std::option::Option<&str> {
        self.evaluation_result.as_deref()
    }
    /// <p>The <code>ErrorDetail</code> object.</p>
    pub fn error(&self) -> std::option::Option<&crate::model::ErrorDetail> {
        self.error.as_ref()
    }
    /// <p>A list of logs that were generated by calls to <code>util.log.info</code> and <code>util.log.error</code> in the evaluated code.</p>
    pub fn logs(&self) -> std::option::Option<&[std::string::String]> {
        self.logs.as_deref()
    }
}
/// See [`EvaluateMappingTemplateOutput`](crate::output::EvaluateMappingTemplateOutput).
pub mod evaluate_mapping_template_output {

    /// A builder for [`EvaluateMappingTemplateOutput`](crate::output::EvaluateMappingTemplateOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) evaluation_result: std::option::Option<std::string::String>,
        pub(crate) error: std::option::Option<crate::model::ErrorDetail>,
        pub(crate) logs: std::option::Option<std::vec::Vec<std::string::String>>,
    }
    impl Builder {
        /// <p>The mapping template; this can be a request or response template.</p>
        pub fn evaluation_result(mut self, input: impl Into<std::string::String>) -> Self {
            self.evaluation_result = Some(input.into());
            self
        }
        /// <p>The mapping template; this can be a request or response template.</p>
        pub fn set_evaluation_result(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.evaluation_result = input;
            self
        }
        /// <p>The <code>ErrorDetail</code> object.</p>
        pub fn error(mut self, input: crate::model::ErrorDetail) -> Self {
            self.error = Some(input);
            self
        }
        /// <p>The <code>ErrorDetail</code> object.</p>
        pub fn set_error(mut self, input: std::option::Option<crate::model::ErrorDetail>) -> Self {
            self.error = input;
            self
        }
        /// Appends an item to `logs`.
        ///
        /// To override the contents of this collection use [`set_logs`](Self::set_logs).
        ///
        /// <p>A list of logs that were generated by calls to <code>util.log.info</code> and <code>util.log.error</code> in the evaluated code.</p>
        pub fn logs(mut self, input: impl Into<std::string::String>) -> Self {
            let mut v = self.logs.unwrap_or_default();
            v.push(input.into());
            self.logs = Some(v);
            self
        }
        /// <p>A list of logs that were generated by calls to <code>util.log.info</code> and <code>util.log.error</code> in the evaluated code.</p>
        pub fn set_logs(
            mut self,
            input: std::option::Option<std::vec::Vec<std::string::String>>,
        ) -> Self {
            self.logs = input;
            self
        }
        /// Consumes the builder and constructs a [`EvaluateMappingTemplateOutput`](crate::output::EvaluateMappingTemplateOutput).
        pub fn build(self) -> crate::output::EvaluateMappingTemplateOutput {
            crate::output::EvaluateMappingTemplateOutput {
                evaluation_result: self.evaluation_result,
                error: self.error,
                logs: self.logs,
            }
        }
    }
}
impl EvaluateMappingTemplateOutput {
    /// Creates a new builder-style object to manufacture [`EvaluateMappingTemplateOutput`](crate::output::EvaluateMappingTemplateOutput).
    pub fn builder() -> crate::output::evaluate_mapping_template_output::Builder {
        crate::output::evaluate_mapping_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 EvaluateCodeOutput {
    /// <p>The result of the evaluation operation.</p>
    #[doc(hidden)]
    pub evaluation_result: std::option::Option<std::string::String>,
    /// <p>Contains the payload of the response error.</p>
    #[doc(hidden)]
    pub error: std::option::Option<crate::model::EvaluateCodeErrorDetail>,
    /// <p>A list of logs that were generated by calls to <code>util.log.info</code> and <code>util.log.error</code> in the evaluated code.</p>
    #[doc(hidden)]
    pub logs: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl EvaluateCodeOutput {
    /// <p>The result of the evaluation operation.</p>
    pub fn evaluation_result(&self) -> std::option::Option<&str> {
        self.evaluation_result.as_deref()
    }
    /// <p>Contains the payload of the response error.</p>
    pub fn error(&self) -> std::option::Option<&crate::model::EvaluateCodeErrorDetail> {
        self.error.as_ref()
    }
    /// <p>A list of logs that were generated by calls to <code>util.log.info</code> and <code>util.log.error</code> in the evaluated code.</p>
    pub fn logs(&self) -> std::option::Option<&[std::string::String]> {
        self.logs.as_deref()
    }
}
/// See [`EvaluateCodeOutput`](crate::output::EvaluateCodeOutput).
pub mod evaluate_code_output {

    /// A builder for [`EvaluateCodeOutput`](crate::output::EvaluateCodeOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) evaluation_result: std::option::Option<std::string::String>,
        pub(crate) error: std::option::Option<crate::model::EvaluateCodeErrorDetail>,
        pub(crate) logs: std::option::Option<std::vec::Vec<std::string::String>>,
    }
    impl Builder {
        /// <p>The result of the evaluation operation.</p>
        pub fn evaluation_result(mut self, input: impl Into<std::string::String>) -> Self {
            self.evaluation_result = Some(input.into());
            self
        }
        /// <p>The result of the evaluation operation.</p>
        pub fn set_evaluation_result(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.evaluation_result = input;
            self
        }
        /// <p>Contains the payload of the response error.</p>
        pub fn error(mut self, input: crate::model::EvaluateCodeErrorDetail) -> Self {
            self.error = Some(input);
            self
        }
        /// <p>Contains the payload of the response error.</p>
        pub fn set_error(
            mut self,
            input: std::option::Option<crate::model::EvaluateCodeErrorDetail>,
        ) -> Self {
            self.error = input;
            self
        }
        /// Appends an item to `logs`.
        ///
        /// To override the contents of this collection use [`set_logs`](Self::set_logs).
        ///
        /// <p>A list of logs that were generated by calls to <code>util.log.info</code> and <code>util.log.error</code> in the evaluated code.</p>
        pub fn logs(mut self, input: impl Into<std::string::String>) -> Self {
            let mut v = self.logs.unwrap_or_default();
            v.push(input.into());
            self.logs = Some(v);
            self
        }
        /// <p>A list of logs that were generated by calls to <code>util.log.info</code> and <code>util.log.error</code> in the evaluated code.</p>
        pub fn set_logs(
            mut self,
            input: std::option::Option<std::vec::Vec<std::string::String>>,
        ) -> Self {
            self.logs = input;
            self
        }
        /// Consumes the builder and constructs a [`EvaluateCodeOutput`](crate::output::EvaluateCodeOutput).
        pub fn build(self) -> crate::output::EvaluateCodeOutput {
            crate::output::EvaluateCodeOutput {
                evaluation_result: self.evaluation_result,
                error: self.error,
                logs: self.logs,
            }
        }
    }
}
impl EvaluateCodeOutput {
    /// Creates a new builder-style object to manufacture [`EvaluateCodeOutput`](crate::output::EvaluateCodeOutput).
    pub fn builder() -> crate::output::evaluate_code_output::Builder {
        crate::output::evaluate_code_output::Builder::default()
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// <p>Represents the output of a <code>DeleteApiCache</code> operation.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteApiCacheOutput {}
/// See [`DeleteApiCacheOutput`](crate::output::DeleteApiCacheOutput).
pub mod delete_api_cache_output {

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateTypeOutput {
    /// <p>The <code>Type</code> object.</p>
    #[doc(hidden)]
    pub r#type: std::option::Option<crate::model::Type>,
}
impl CreateTypeOutput {
    /// <p>The <code>Type</code> object.</p>
    pub fn r#type(&self) -> std::option::Option<&crate::model::Type> {
        self.r#type.as_ref()
    }
}
/// See [`CreateTypeOutput`](crate::output::CreateTypeOutput).
pub mod create_type_output {

    /// A builder for [`CreateTypeOutput`](crate::output::CreateTypeOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) r#type: std::option::Option<crate::model::Type>,
    }
    impl Builder {
        /// <p>The <code>Type</code> object.</p>
        pub fn r#type(mut self, input: crate::model::Type) -> Self {
            self.r#type = Some(input);
            self
        }
        /// <p>The <code>Type</code> object.</p>
        pub fn set_type(mut self, input: std::option::Option<crate::model::Type>) -> Self {
            self.r#type = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateTypeOutput`](crate::output::CreateTypeOutput).
        pub fn build(self) -> crate::output::CreateTypeOutput {
            crate::output::CreateTypeOutput {
                r#type: self.r#type,
            }
        }
    }
}
impl CreateTypeOutput {
    /// Creates a new builder-style object to manufacture [`CreateTypeOutput`](crate::output::CreateTypeOutput).
    pub fn builder() -> crate::output::create_type_output::Builder {
        crate::output::create_type_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateResolverOutput {
    /// <p>The <code>Resolver</code> object.</p>
    #[doc(hidden)]
    pub resolver: std::option::Option<crate::model::Resolver>,
}
impl CreateResolverOutput {
    /// <p>The <code>Resolver</code> object.</p>
    pub fn resolver(&self) -> std::option::Option<&crate::model::Resolver> {
        self.resolver.as_ref()
    }
}
/// See [`CreateResolverOutput`](crate::output::CreateResolverOutput).
pub mod create_resolver_output {

    /// A builder for [`CreateResolverOutput`](crate::output::CreateResolverOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) resolver: std::option::Option<crate::model::Resolver>,
    }
    impl Builder {
        /// <p>The <code>Resolver</code> object.</p>
        pub fn resolver(mut self, input: crate::model::Resolver) -> Self {
            self.resolver = Some(input);
            self
        }
        /// <p>The <code>Resolver</code> object.</p>
        pub fn set_resolver(mut self, input: std::option::Option<crate::model::Resolver>) -> Self {
            self.resolver = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateResolverOutput`](crate::output::CreateResolverOutput).
        pub fn build(self) -> crate::output::CreateResolverOutput {
            crate::output::CreateResolverOutput {
                resolver: self.resolver,
            }
        }
    }
}
impl CreateResolverOutput {
    /// Creates a new builder-style object to manufacture [`CreateResolverOutput`](crate::output::CreateResolverOutput).
    pub fn builder() -> crate::output::create_resolver_output::Builder {
        crate::output::create_resolver_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateGraphqlApiOutput {
    /// <p>The <code>GraphqlApi</code>.</p>
    #[doc(hidden)]
    pub graphql_api: std::option::Option<crate::model::GraphqlApi>,
}
impl CreateGraphqlApiOutput {
    /// <p>The <code>GraphqlApi</code>.</p>
    pub fn graphql_api(&self) -> std::option::Option<&crate::model::GraphqlApi> {
        self.graphql_api.as_ref()
    }
}
/// See [`CreateGraphqlApiOutput`](crate::output::CreateGraphqlApiOutput).
pub mod create_graphql_api_output {

    /// A builder for [`CreateGraphqlApiOutput`](crate::output::CreateGraphqlApiOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) graphql_api: std::option::Option<crate::model::GraphqlApi>,
    }
    impl Builder {
        /// <p>The <code>GraphqlApi</code>.</p>
        pub fn graphql_api(mut self, input: crate::model::GraphqlApi) -> Self {
            self.graphql_api = Some(input);
            self
        }
        /// <p>The <code>GraphqlApi</code>.</p>
        pub fn set_graphql_api(
            mut self,
            input: std::option::Option<crate::model::GraphqlApi>,
        ) -> Self {
            self.graphql_api = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateGraphqlApiOutput`](crate::output::CreateGraphqlApiOutput).
        pub fn build(self) -> crate::output::CreateGraphqlApiOutput {
            crate::output::CreateGraphqlApiOutput {
                graphql_api: self.graphql_api,
            }
        }
    }
}
impl CreateGraphqlApiOutput {
    /// Creates a new builder-style object to manufacture [`CreateGraphqlApiOutput`](crate::output::CreateGraphqlApiOutput).
    pub fn builder() -> crate::output::create_graphql_api_output::Builder {
        crate::output::create_graphql_api_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateFunctionOutput {
    /// <p>The <code>Function</code> object.</p>
    #[doc(hidden)]
    pub function_configuration: std::option::Option<crate::model::FunctionConfiguration>,
}
impl CreateFunctionOutput {
    /// <p>The <code>Function</code> object.</p>
    pub fn function_configuration(
        &self,
    ) -> std::option::Option<&crate::model::FunctionConfiguration> {
        self.function_configuration.as_ref()
    }
}
/// See [`CreateFunctionOutput`](crate::output::CreateFunctionOutput).
pub mod create_function_output {

    /// A builder for [`CreateFunctionOutput`](crate::output::CreateFunctionOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) function_configuration: std::option::Option<crate::model::FunctionConfiguration>,
    }
    impl Builder {
        /// <p>The <code>Function</code> object.</p>
        pub fn function_configuration(
            mut self,
            input: crate::model::FunctionConfiguration,
        ) -> Self {
            self.function_configuration = Some(input);
            self
        }
        /// <p>The <code>Function</code> object.</p>
        pub fn set_function_configuration(
            mut self,
            input: std::option::Option<crate::model::FunctionConfiguration>,
        ) -> Self {
            self.function_configuration = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateFunctionOutput`](crate::output::CreateFunctionOutput).
        pub fn build(self) -> crate::output::CreateFunctionOutput {
            crate::output::CreateFunctionOutput {
                function_configuration: self.function_configuration,
            }
        }
    }
}
impl CreateFunctionOutput {
    /// Creates a new builder-style object to manufacture [`CreateFunctionOutput`](crate::output::CreateFunctionOutput).
    pub fn builder() -> crate::output::create_function_output::Builder {
        crate::output::create_function_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateDomainNameOutput {
    /// <p>The configuration for the <code>DomainName</code>.</p>
    #[doc(hidden)]
    pub domain_name_config: std::option::Option<crate::model::DomainNameConfig>,
}
impl CreateDomainNameOutput {
    /// <p>The configuration for the <code>DomainName</code>.</p>
    pub fn domain_name_config(&self) -> std::option::Option<&crate::model::DomainNameConfig> {
        self.domain_name_config.as_ref()
    }
}
/// See [`CreateDomainNameOutput`](crate::output::CreateDomainNameOutput).
pub mod create_domain_name_output {

    /// A builder for [`CreateDomainNameOutput`](crate::output::CreateDomainNameOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) domain_name_config: std::option::Option<crate::model::DomainNameConfig>,
    }
    impl Builder {
        /// <p>The configuration for the <code>DomainName</code>.</p>
        pub fn domain_name_config(mut self, input: crate::model::DomainNameConfig) -> Self {
            self.domain_name_config = Some(input);
            self
        }
        /// <p>The configuration for the <code>DomainName</code>.</p>
        pub fn set_domain_name_config(
            mut self,
            input: std::option::Option<crate::model::DomainNameConfig>,
        ) -> Self {
            self.domain_name_config = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateDomainNameOutput`](crate::output::CreateDomainNameOutput).
        pub fn build(self) -> crate::output::CreateDomainNameOutput {
            crate::output::CreateDomainNameOutput {
                domain_name_config: self.domain_name_config,
            }
        }
    }
}
impl CreateDomainNameOutput {
    /// Creates a new builder-style object to manufacture [`CreateDomainNameOutput`](crate::output::CreateDomainNameOutput).
    pub fn builder() -> crate::output::create_domain_name_output::Builder {
        crate::output::create_domain_name_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateDataSourceOutput {
    /// <p>The <code>DataSource</code> object.</p>
    #[doc(hidden)]
    pub data_source: std::option::Option<crate::model::DataSource>,
}
impl CreateDataSourceOutput {
    /// <p>The <code>DataSource</code> object.</p>
    pub fn data_source(&self) -> std::option::Option<&crate::model::DataSource> {
        self.data_source.as_ref()
    }
}
/// See [`CreateDataSourceOutput`](crate::output::CreateDataSourceOutput).
pub mod create_data_source_output {

    /// A builder for [`CreateDataSourceOutput`](crate::output::CreateDataSourceOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) data_source: std::option::Option<crate::model::DataSource>,
    }
    impl Builder {
        /// <p>The <code>DataSource</code> object.</p>
        pub fn data_source(mut self, input: crate::model::DataSource) -> Self {
            self.data_source = Some(input);
            self
        }
        /// <p>The <code>DataSource</code> object.</p>
        pub fn set_data_source(
            mut self,
            input: std::option::Option<crate::model::DataSource>,
        ) -> Self {
            self.data_source = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateDataSourceOutput`](crate::output::CreateDataSourceOutput).
        pub fn build(self) -> crate::output::CreateDataSourceOutput {
            crate::output::CreateDataSourceOutput {
                data_source: self.data_source,
            }
        }
    }
}
impl CreateDataSourceOutput {
    /// Creates a new builder-style object to manufacture [`CreateDataSourceOutput`](crate::output::CreateDataSourceOutput).
    pub fn builder() -> crate::output::create_data_source_output::Builder {
        crate::output::create_data_source_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateApiKeyOutput {
    /// <p>The API key.</p>
    #[doc(hidden)]
    pub api_key: std::option::Option<crate::model::ApiKey>,
}
impl CreateApiKeyOutput {
    /// <p>The API key.</p>
    pub fn api_key(&self) -> std::option::Option<&crate::model::ApiKey> {
        self.api_key.as_ref()
    }
}
/// See [`CreateApiKeyOutput`](crate::output::CreateApiKeyOutput).
pub mod create_api_key_output {

    /// A builder for [`CreateApiKeyOutput`](crate::output::CreateApiKeyOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) api_key: std::option::Option<crate::model::ApiKey>,
    }
    impl Builder {
        /// <p>The API key.</p>
        pub fn api_key(mut self, input: crate::model::ApiKey) -> Self {
            self.api_key = Some(input);
            self
        }
        /// <p>The API key.</p>
        pub fn set_api_key(mut self, input: std::option::Option<crate::model::ApiKey>) -> Self {
            self.api_key = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateApiKeyOutput`](crate::output::CreateApiKeyOutput).
        pub fn build(self) -> crate::output::CreateApiKeyOutput {
            crate::output::CreateApiKeyOutput {
                api_key: self.api_key,
            }
        }
    }
}
impl CreateApiKeyOutput {
    /// Creates a new builder-style object to manufacture [`CreateApiKeyOutput`](crate::output::CreateApiKeyOutput).
    pub fn builder() -> crate::output::create_api_key_output::Builder {
        crate::output::create_api_key_output::Builder::default()
    }
}

/// <p>Represents the output of a <code>CreateApiCache</code> operation.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateApiCacheOutput {
    /// <p>The <code>ApiCache</code> object.</p>
    #[doc(hidden)]
    pub api_cache: std::option::Option<crate::model::ApiCache>,
}
impl CreateApiCacheOutput {
    /// <p>The <code>ApiCache</code> object.</p>
    pub fn api_cache(&self) -> std::option::Option<&crate::model::ApiCache> {
        self.api_cache.as_ref()
    }
}
/// See [`CreateApiCacheOutput`](crate::output::CreateApiCacheOutput).
pub mod create_api_cache_output {

    /// A builder for [`CreateApiCacheOutput`](crate::output::CreateApiCacheOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) api_cache: std::option::Option<crate::model::ApiCache>,
    }
    impl Builder {
        /// <p>The <code>ApiCache</code> object.</p>
        pub fn api_cache(mut self, input: crate::model::ApiCache) -> Self {
            self.api_cache = Some(input);
            self
        }
        /// <p>The <code>ApiCache</code> object.</p>
        pub fn set_api_cache(mut self, input: std::option::Option<crate::model::ApiCache>) -> Self {
            self.api_cache = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateApiCacheOutput`](crate::output::CreateApiCacheOutput).
        pub fn build(self) -> crate::output::CreateApiCacheOutput {
            crate::output::CreateApiCacheOutput {
                api_cache: self.api_cache,
            }
        }
    }
}
impl CreateApiCacheOutput {
    /// Creates a new builder-style object to manufacture [`CreateApiCacheOutput`](crate::output::CreateApiCacheOutput).
    pub fn builder() -> crate::output::create_api_cache_output::Builder {
        crate::output::create_api_cache_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct AssociateApiOutput {
    /// <p>The <code>ApiAssociation</code> object.</p>
    #[doc(hidden)]
    pub api_association: std::option::Option<crate::model::ApiAssociation>,
}
impl AssociateApiOutput {
    /// <p>The <code>ApiAssociation</code> object.</p>
    pub fn api_association(&self) -> std::option::Option<&crate::model::ApiAssociation> {
        self.api_association.as_ref()
    }
}
/// See [`AssociateApiOutput`](crate::output::AssociateApiOutput).
pub mod associate_api_output {

    /// A builder for [`AssociateApiOutput`](crate::output::AssociateApiOutput).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) api_association: std::option::Option<crate::model::ApiAssociation>,
    }
    impl Builder {
        /// <p>The <code>ApiAssociation</code> object.</p>
        pub fn api_association(mut self, input: crate::model::ApiAssociation) -> Self {
            self.api_association = Some(input);
            self
        }
        /// <p>The <code>ApiAssociation</code> object.</p>
        pub fn set_api_association(
            mut self,
            input: std::option::Option<crate::model::ApiAssociation>,
        ) -> Self {
            self.api_association = input;
            self
        }
        /// Consumes the builder and constructs a [`AssociateApiOutput`](crate::output::AssociateApiOutput).
        pub fn build(self) -> crate::output::AssociateApiOutput {
            crate::output::AssociateApiOutput {
                api_association: self.api_association,
            }
        }
    }
}
impl AssociateApiOutput {
    /// Creates a new builder-style object to manufacture [`AssociateApiOutput`](crate::output::AssociateApiOutput).
    pub fn builder() -> crate::output::associate_api_output::Builder {
        crate::output::associate_api_output::Builder::default()
    }
}