aws-sdk-appsync 0.0.23-alpha

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateTypeOutput {
    /// <p>The updated <code>Type</code> object.</p>
    pub r#type: std::option::Option<crate::model::Type>,
}
impl std::fmt::Debug for UpdateTypeOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateTypeOutput");
        formatter.field("r#type", &self.r#type);
        formatter.finish()
    }
}
/// See [`UpdateTypeOutput`](crate::output::UpdateTypeOutput)
pub mod update_type_output {
    /// A builder for [`UpdateTypeOutput`](crate::output::UpdateTypeOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, 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)]
pub struct UpdateResolverOutput {
    /// <p>The updated <code>Resolver</code> object.</p>
    pub resolver: std::option::Option<crate::model::Resolver>,
}
impl std::fmt::Debug for UpdateResolverOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateResolverOutput");
        formatter.field("resolver", &self.resolver);
        formatter.finish()
    }
}
/// See [`UpdateResolverOutput`](crate::output::UpdateResolverOutput)
pub mod update_resolver_output {
    /// A builder for [`UpdateResolverOutput`](crate::output::UpdateResolverOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, 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)]
pub struct UpdateGraphqlApiOutput {
    /// <p>The updated <code>GraphqlApi</code> object.</p>
    pub graphql_api: std::option::Option<crate::model::GraphqlApi>,
}
impl std::fmt::Debug for UpdateGraphqlApiOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateGraphqlApiOutput");
        formatter.field("graphql_api", &self.graphql_api);
        formatter.finish()
    }
}
/// See [`UpdateGraphqlApiOutput`](crate::output::UpdateGraphqlApiOutput)
pub mod update_graphql_api_output {
    /// A builder for [`UpdateGraphqlApiOutput`](crate::output::UpdateGraphqlApiOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, 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)]
pub struct UpdateFunctionOutput {
    /// <p>The <code>Function</code> object.</p>
    pub function_configuration: std::option::Option<crate::model::FunctionConfiguration>,
}
impl std::fmt::Debug for UpdateFunctionOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateFunctionOutput");
        formatter.field("function_configuration", &self.function_configuration);
        formatter.finish()
    }
}
/// See [`UpdateFunctionOutput`](crate::output::UpdateFunctionOutput)
pub mod update_function_output {
    /// A builder for [`UpdateFunctionOutput`](crate::output::UpdateFunctionOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, 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)]
pub struct UpdateDataSourceOutput {
    /// <p>The updated <code>DataSource</code> object.</p>
    pub data_source: std::option::Option<crate::model::DataSource>,
}
impl std::fmt::Debug for UpdateDataSourceOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateDataSourceOutput");
        formatter.field("data_source", &self.data_source);
        formatter.finish()
    }
}
/// See [`UpdateDataSourceOutput`](crate::output::UpdateDataSourceOutput)
pub mod update_data_source_output {
    /// A builder for [`UpdateDataSourceOutput`](crate::output::UpdateDataSourceOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, 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)]
pub struct UpdateApiKeyOutput {
    /// <p>The API key.</p>
    pub api_key: std::option::Option<crate::model::ApiKey>,
}
impl std::fmt::Debug for UpdateApiKeyOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateApiKeyOutput");
        formatter.field("api_key", &self.api_key);
        formatter.finish()
    }
}
/// See [`UpdateApiKeyOutput`](crate::output::UpdateApiKeyOutput)
pub mod update_api_key_output {
    /// A builder for [`UpdateApiKeyOutput`](crate::output::UpdateApiKeyOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, 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)]
pub struct UpdateApiCacheOutput {
    /// <p>The <code>ApiCache</code> object.</p>
    pub api_cache: std::option::Option<crate::model::ApiCache>,
}
impl std::fmt::Debug for UpdateApiCacheOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateApiCacheOutput");
        formatter.field("api_cache", &self.api_cache);
        formatter.finish()
    }
}
/// See [`UpdateApiCacheOutput`](crate::output::UpdateApiCacheOutput)
pub mod update_api_cache_output {
    /// A builder for [`UpdateApiCacheOutput`](crate::output::UpdateApiCacheOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, 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)]
pub struct UntagResourceOutput {}
impl std::fmt::Debug for UntagResourceOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UntagResourceOutput");
        formatter.finish()
    }
}
/// See [`UntagResourceOutput`](crate::output::UntagResourceOutput)
pub mod untag_resource_output {
    /// A builder for [`UntagResourceOutput`](crate::output::UntagResourceOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {}
    impl Builder {
        /// Consumes the builder and constructs a [`UntagResourceOutput`](crate::output::UntagResourceOutput)
        pub fn build(self) -> crate::output::UntagResourceOutput {
            crate::output::UntagResourceOutput {}
        }
    }
}
impl UntagResourceOutput {
    /// Creates a new builder-style object to manufacture [`UntagResourceOutput`](crate::output::UntagResourceOutput)
    pub fn builder() -> crate::output::untag_resource_output::Builder {
        crate::output::untag_resource_output::Builder::default()
    }
}

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct 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 status: std::option::Option<crate::model::SchemaStatus>,
}
impl std::fmt::Debug for StartSchemaCreationOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("StartSchemaCreationOutput");
        formatter.field("status", &self.status);
        formatter.finish()
    }
}
/// See [`StartSchemaCreationOutput`](crate::output::StartSchemaCreationOutput)
pub mod start_schema_creation_output {
    /// A builder for [`StartSchemaCreationOutput`](crate::output::StartSchemaCreationOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) status: std::option::Option<crate::model::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)]
pub struct ListTypesOutput {
    /// <p>The <code>Type</code> objects.</p>
    pub types: std::option::Option<std::vec::Vec<crate::model::Type>>,
    /// <p>An identifier to be passed in the next request to this operation to return the next set
    /// of items in the list.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for ListTypesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListTypesOutput");
        formatter.field("types", &self.types);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListTypesOutput`](crate::output::ListTypesOutput)
pub mod list_types_output {
    /// A builder for [`ListTypesOutput`](crate::output::ListTypesOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, 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: impl Into<crate::model::Type>) -> Self {
            let mut v = self.types.unwrap_or_default();
            v.push(input.into());
            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 be passed 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 be passed 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)]
pub struct ListTagsForResourceOutput {
    /// <p>A <code>TagMap</code> object.</p>
    pub tags:
        std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl std::fmt::Debug for ListTagsForResourceOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListTagsForResourceOutput");
        formatter.field("tags", &self.tags);
        formatter.finish()
    }
}
/// See [`ListTagsForResourceOutput`](crate::output::ListTagsForResourceOutput)
pub mod list_tags_for_resource_output {
    /// A builder for [`ListTagsForResourceOutput`](crate::output::ListTagsForResourceOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) tags: std::option::Option<
            std::collections::HashMap<std::string::String, std::string::String>,
        >,
    }
    impl Builder {
        /// Adds a key-value pair to `tags`.
        ///
        /// To override the contents of this collection use [`set_tags`](Self::set_tags).
        ///
        /// <p>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)]
pub struct ListResolversByFunctionOutput {
    /// <p>The list of resolvers.</p>
    pub resolvers: std::option::Option<std::vec::Vec<crate::model::Resolver>>,
    /// <p>An identifier that can be used to return the next set of items in the list.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for ListResolversByFunctionOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListResolversByFunctionOutput");
        formatter.field("resolvers", &self.resolvers);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListResolversByFunctionOutput`](crate::output::ListResolversByFunctionOutput)
pub mod list_resolvers_by_function_output {
    /// A builder for [`ListResolversByFunctionOutput`](crate::output::ListResolversByFunctionOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, 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: impl Into<crate::model::Resolver>) -> Self {
            let mut v = self.resolvers.unwrap_or_default();
            v.push(input.into());
            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 can be used 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 can be used 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)]
pub struct ListResolversOutput {
    /// <p>The <code>Resolver</code> objects.</p>
    pub resolvers: std::option::Option<std::vec::Vec<crate::model::Resolver>>,
    /// <p>An identifier to be passed in the next request to this operation to return the next set
    /// of items in the list.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for ListResolversOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListResolversOutput");
        formatter.field("resolvers", &self.resolvers);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListResolversOutput`](crate::output::ListResolversOutput)
pub mod list_resolvers_output {
    /// A builder for [`ListResolversOutput`](crate::output::ListResolversOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, 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: impl Into<crate::model::Resolver>) -> Self {
            let mut v = self.resolvers.unwrap_or_default();
            v.push(input.into());
            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 be passed 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 be passed 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)]
pub struct ListGraphqlApisOutput {
    /// <p>The <code>GraphqlApi</code> objects.</p>
    pub graphql_apis: std::option::Option<std::vec::Vec<crate::model::GraphqlApi>>,
    /// <p>An identifier to be passed in the next request to this operation to return the next set
    /// of items in the list.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for ListGraphqlApisOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListGraphqlApisOutput");
        formatter.field("graphql_apis", &self.graphql_apis);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListGraphqlApisOutput`](crate::output::ListGraphqlApisOutput)
pub mod list_graphql_apis_output {
    /// A builder for [`ListGraphqlApisOutput`](crate::output::ListGraphqlApisOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, 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: impl Into<crate::model::GraphqlApi>) -> Self {
            let mut v = self.graphql_apis.unwrap_or_default();
            v.push(input.into());
            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 be passed 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 be passed 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)]
pub struct ListFunctionsOutput {
    /// <p>A list of <code>Function</code> objects.</p>
    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 can be
    /// used to return the next set of items in the list.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for ListFunctionsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListFunctionsOutput");
        formatter.field("functions", &self.functions);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListFunctionsOutput`](crate::output::ListFunctionsOutput)
pub mod list_functions_output {
    /// A builder for [`ListFunctionsOutput`](crate::output::ListFunctionsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, 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: impl Into<crate::model::FunctionConfiguration>) -> Self {
            let mut v = self.functions.unwrap_or_default();
            v.push(input.into());
            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 can be
        /// used 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 can be
        /// used 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)]
pub struct ListDataSourcesOutput {
    /// <p>The <code>DataSource</code> objects.</p>
    pub data_sources: std::option::Option<std::vec::Vec<crate::model::DataSource>>,
    /// <p>An identifier to be passed in the next request to this operation to return the next set
    /// of items in the list.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for ListDataSourcesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListDataSourcesOutput");
        formatter.field("data_sources", &self.data_sources);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListDataSourcesOutput`](crate::output::ListDataSourcesOutput)
pub mod list_data_sources_output {
    /// A builder for [`ListDataSourcesOutput`](crate::output::ListDataSourcesOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, 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: impl Into<crate::model::DataSource>) -> Self {
            let mut v = self.data_sources.unwrap_or_default();
            v.push(input.into());
            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 be passed 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 be passed 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)]
pub struct ListApiKeysOutput {
    /// <p>The <code>ApiKey</code> objects.</p>
    pub api_keys: std::option::Option<std::vec::Vec<crate::model::ApiKey>>,
    /// <p>An identifier to be passed in the next request to this operation to return the next set
    /// of items in the list.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for ListApiKeysOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListApiKeysOutput");
        formatter.field("api_keys", &self.api_keys);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListApiKeysOutput`](crate::output::ListApiKeysOutput)
pub mod list_api_keys_output {
    /// A builder for [`ListApiKeysOutput`](crate::output::ListApiKeysOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, 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: impl Into<crate::model::ApiKey>) -> Self {
            let mut v = self.api_keys.unwrap_or_default();
            v.push(input.into());
            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 be passed 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 be passed 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)]
pub struct GetTypeOutput {
    /// <p>The <code>Type</code> object.</p>
    pub r#type: std::option::Option<crate::model::Type>,
}
impl std::fmt::Debug for GetTypeOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetTypeOutput");
        formatter.field("r#type", &self.r#type);
        formatter.finish()
    }
}
/// See [`GetTypeOutput`](crate::output::GetTypeOutput)
pub mod get_type_output {
    /// A builder for [`GetTypeOutput`](crate::output::GetTypeOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, 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)]
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>
    pub status: std::option::Option<crate::model::SchemaStatus>,
    /// <p>Detailed information about the status of the schema creation operation.</p>
    pub details: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for GetSchemaCreationStatusOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetSchemaCreationStatusOutput");
        formatter.field("status", &self.status);
        formatter.field("details", &self.details);
        formatter.finish()
    }
}
/// See [`GetSchemaCreationStatusOutput`](crate::output::GetSchemaCreationStatusOutput)
pub mod get_schema_creation_status_output {
    /// A builder for [`GetSchemaCreationStatusOutput`](crate::output::GetSchemaCreationStatusOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) status: std::option::Option<crate::model::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)]
pub struct GetResolverOutput {
    /// <p>The <code>Resolver</code> object.</p>
    pub resolver: std::option::Option<crate::model::Resolver>,
}
impl std::fmt::Debug for GetResolverOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetResolverOutput");
        formatter.field("resolver", &self.resolver);
        formatter.finish()
    }
}
/// See [`GetResolverOutput`](crate::output::GetResolverOutput)
pub mod get_resolver_output {
    /// A builder for [`GetResolverOutput`](crate::output::GetResolverOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, 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)]
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>
    pub schema: std::option::Option<aws_smithy_types::Blob>,
}
impl std::fmt::Debug for GetIntrospectionSchemaOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetIntrospectionSchemaOutput");
        formatter.field("schema", &self.schema);
        formatter.finish()
    }
}
/// See [`GetIntrospectionSchemaOutput`](crate::output::GetIntrospectionSchemaOutput)
pub mod get_introspection_schema_output {
    /// A builder for [`GetIntrospectionSchemaOutput`](crate::output::GetIntrospectionSchemaOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, 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)]
pub struct GetGraphqlApiOutput {
    /// <p>The <code>GraphqlApi</code> object.</p>
    pub graphql_api: std::option::Option<crate::model::GraphqlApi>,
}
impl std::fmt::Debug for GetGraphqlApiOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetGraphqlApiOutput");
        formatter.field("graphql_api", &self.graphql_api);
        formatter.finish()
    }
}
/// See [`GetGraphqlApiOutput`](crate::output::GetGraphqlApiOutput)
pub mod get_graphql_api_output {
    /// A builder for [`GetGraphqlApiOutput`](crate::output::GetGraphqlApiOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, 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)]
pub struct GetFunctionOutput {
    /// <p>The <code>Function</code> object.</p>
    pub function_configuration: std::option::Option<crate::model::FunctionConfiguration>,
}
impl std::fmt::Debug for GetFunctionOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetFunctionOutput");
        formatter.field("function_configuration", &self.function_configuration);
        formatter.finish()
    }
}
/// See [`GetFunctionOutput`](crate::output::GetFunctionOutput)
pub mod get_function_output {
    /// A builder for [`GetFunctionOutput`](crate::output::GetFunctionOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, 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)]
pub struct GetDataSourceOutput {
    /// <p>The <code>DataSource</code> object.</p>
    pub data_source: std::option::Option<crate::model::DataSource>,
}
impl std::fmt::Debug for GetDataSourceOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetDataSourceOutput");
        formatter.field("data_source", &self.data_source);
        formatter.finish()
    }
}
/// See [`GetDataSourceOutput`](crate::output::GetDataSourceOutput)
pub mod get_data_source_output {
    /// A builder for [`GetDataSourceOutput`](crate::output::GetDataSourceOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, 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)]
pub struct GetApiCacheOutput {
    /// <p>The <code>ApiCache</code> object.</p>
    pub api_cache: std::option::Option<crate::model::ApiCache>,
}
impl std::fmt::Debug for GetApiCacheOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetApiCacheOutput");
        formatter.field("api_cache", &self.api_cache);
        formatter.finish()
    }
}
/// See [`GetApiCacheOutput`](crate::output::GetApiCacheOutput)
pub mod get_api_cache_output {
    /// A builder for [`GetApiCacheOutput`](crate::output::GetApiCacheOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, 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()
    }
}

/// <p>Represents the output of a <code>FlushApiCache</code> operation.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct FlushApiCacheOutput {}
impl std::fmt::Debug for FlushApiCacheOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("FlushApiCacheOutput");
        formatter.finish()
    }
}
/// See [`FlushApiCacheOutput`](crate::output::FlushApiCacheOutput)
pub mod flush_api_cache_output {
    /// A builder for [`FlushApiCacheOutput`](crate::output::FlushApiCacheOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {}
    impl Builder {
        /// Consumes the builder and constructs a [`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)]
pub struct DeleteTypeOutput {}
impl std::fmt::Debug for DeleteTypeOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteTypeOutput");
        formatter.finish()
    }
}
/// See [`DeleteTypeOutput`](crate::output::DeleteTypeOutput)
pub mod delete_type_output {
    /// A builder for [`DeleteTypeOutput`](crate::output::DeleteTypeOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {}
    impl Builder {
        /// Consumes the builder and constructs a [`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)]
pub struct DeleteResolverOutput {}
impl std::fmt::Debug for DeleteResolverOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteResolverOutput");
        formatter.finish()
    }
}
/// See [`DeleteResolverOutput`](crate::output::DeleteResolverOutput)
pub mod delete_resolver_output {
    /// A builder for [`DeleteResolverOutput`](crate::output::DeleteResolverOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {}
    impl Builder {
        /// Consumes the builder and constructs a [`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)]
pub struct DeleteGraphqlApiOutput {}
impl std::fmt::Debug for DeleteGraphqlApiOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteGraphqlApiOutput");
        formatter.finish()
    }
}
/// See [`DeleteGraphqlApiOutput`](crate::output::DeleteGraphqlApiOutput)
pub mod delete_graphql_api_output {
    /// A builder for [`DeleteGraphqlApiOutput`](crate::output::DeleteGraphqlApiOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {}
    impl Builder {
        /// Consumes the builder and constructs a [`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)]
pub struct DeleteFunctionOutput {}
impl std::fmt::Debug for DeleteFunctionOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteFunctionOutput");
        formatter.finish()
    }
}
/// See [`DeleteFunctionOutput`](crate::output::DeleteFunctionOutput)
pub mod delete_function_output {
    /// A builder for [`DeleteFunctionOutput`](crate::output::DeleteFunctionOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {}
    impl Builder {
        /// Consumes the builder and constructs a [`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)]
pub struct DeleteDataSourceOutput {}
impl std::fmt::Debug for DeleteDataSourceOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteDataSourceOutput");
        formatter.finish()
    }
}
/// See [`DeleteDataSourceOutput`](crate::output::DeleteDataSourceOutput)
pub mod delete_data_source_output {
    /// A builder for [`DeleteDataSourceOutput`](crate::output::DeleteDataSourceOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {}
    impl Builder {
        /// Consumes the builder and constructs a [`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)]
pub struct DeleteApiKeyOutput {}
impl std::fmt::Debug for DeleteApiKeyOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteApiKeyOutput");
        formatter.finish()
    }
}
/// See [`DeleteApiKeyOutput`](crate::output::DeleteApiKeyOutput)
pub mod delete_api_key_output {
    /// A builder for [`DeleteApiKeyOutput`](crate::output::DeleteApiKeyOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {}
    impl Builder {
        /// Consumes the builder and constructs a [`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)]
pub struct DeleteApiCacheOutput {}
impl std::fmt::Debug for DeleteApiCacheOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteApiCacheOutput");
        formatter.finish()
    }
}
/// See [`DeleteApiCacheOutput`](crate::output::DeleteApiCacheOutput)
pub mod delete_api_cache_output {
    /// A builder for [`DeleteApiCacheOutput`](crate::output::DeleteApiCacheOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {}
    impl Builder {
        /// Consumes the builder and constructs a [`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)]
pub struct CreateTypeOutput {
    /// <p>The <code>Type</code> object.</p>
    pub r#type: std::option::Option<crate::model::Type>,
}
impl std::fmt::Debug for CreateTypeOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateTypeOutput");
        formatter.field("r#type", &self.r#type);
        formatter.finish()
    }
}
/// See [`CreateTypeOutput`](crate::output::CreateTypeOutput)
pub mod create_type_output {
    /// A builder for [`CreateTypeOutput`](crate::output::CreateTypeOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, 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)]
pub struct CreateResolverOutput {
    /// <p>The <code>Resolver</code> object.</p>
    pub resolver: std::option::Option<crate::model::Resolver>,
}
impl std::fmt::Debug for CreateResolverOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateResolverOutput");
        formatter.field("resolver", &self.resolver);
        formatter.finish()
    }
}
/// See [`CreateResolverOutput`](crate::output::CreateResolverOutput)
pub mod create_resolver_output {
    /// A builder for [`CreateResolverOutput`](crate::output::CreateResolverOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, 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)]
pub struct CreateGraphqlApiOutput {
    /// <p>The <code>GraphqlApi</code>.</p>
    pub graphql_api: std::option::Option<crate::model::GraphqlApi>,
}
impl std::fmt::Debug for CreateGraphqlApiOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateGraphqlApiOutput");
        formatter.field("graphql_api", &self.graphql_api);
        formatter.finish()
    }
}
/// See [`CreateGraphqlApiOutput`](crate::output::CreateGraphqlApiOutput)
pub mod create_graphql_api_output {
    /// A builder for [`CreateGraphqlApiOutput`](crate::output::CreateGraphqlApiOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, 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)]
pub struct CreateFunctionOutput {
    /// <p>The <code>Function</code> object.</p>
    pub function_configuration: std::option::Option<crate::model::FunctionConfiguration>,
}
impl std::fmt::Debug for CreateFunctionOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateFunctionOutput");
        formatter.field("function_configuration", &self.function_configuration);
        formatter.finish()
    }
}
/// See [`CreateFunctionOutput`](crate::output::CreateFunctionOutput)
pub mod create_function_output {
    /// A builder for [`CreateFunctionOutput`](crate::output::CreateFunctionOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, 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)]
pub struct CreateDataSourceOutput {
    /// <p>The <code>DataSource</code> object.</p>
    pub data_source: std::option::Option<crate::model::DataSource>,
}
impl std::fmt::Debug for CreateDataSourceOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateDataSourceOutput");
        formatter.field("data_source", &self.data_source);
        formatter.finish()
    }
}
/// See [`CreateDataSourceOutput`](crate::output::CreateDataSourceOutput)
pub mod create_data_source_output {
    /// A builder for [`CreateDataSourceOutput`](crate::output::CreateDataSourceOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, 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)]
pub struct CreateApiKeyOutput {
    /// <p>The API key.</p>
    pub api_key: std::option::Option<crate::model::ApiKey>,
}
impl std::fmt::Debug for CreateApiKeyOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateApiKeyOutput");
        formatter.field("api_key", &self.api_key);
        formatter.finish()
    }
}
/// See [`CreateApiKeyOutput`](crate::output::CreateApiKeyOutput)
pub mod create_api_key_output {
    /// A builder for [`CreateApiKeyOutput`](crate::output::CreateApiKeyOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, 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)]
pub struct CreateApiCacheOutput {
    /// <p>The <code>ApiCache</code> object.</p>
    pub api_cache: std::option::Option<crate::model::ApiCache>,
}
impl std::fmt::Debug for CreateApiCacheOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateApiCacheOutput");
        formatter.field("api_cache", &self.api_cache);
        formatter.finish()
    }
}
/// See [`CreateApiCacheOutput`](crate::output::CreateApiCacheOutput)
pub mod create_api_cache_output {
    /// A builder for [`CreateApiCacheOutput`](crate::output::CreateApiCacheOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, 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()
    }
}