google_cloud_documentai_v1/

builder.rs

// Copyright 2025 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Code generated by sidekick. DO NOT EDIT.

/// Request and client builders for [DocumentProcessorService][crate::client::DocumentProcessorService].
pub mod document_processor_service {
    use crate::Result;

    /// A builder for [DocumentProcessorService][crate::client::DocumentProcessorService].
    ///
    /// ```
    /// # async fn sample() -> google_cloud_gax::client_builder::Result<()> {
    /// # use google_cloud_documentai_v1::*;
    /// # use builder::document_processor_service::ClientBuilder;
    /// # use client::DocumentProcessorService;
    /// let builder : ClientBuilder = DocumentProcessorService::builder();
    /// let client = builder
    ///     .with_endpoint("https://documentai.googleapis.com")
    ///     .build().await?;
    /// # Ok(()) }
    /// ```
    pub type ClientBuilder = crate::ClientBuilder<client::Factory, gaxi::options::Credentials>;

    pub(crate) mod client {
        use super::super::super::client::DocumentProcessorService;
        pub struct Factory;
        impl crate::ClientFactory for Factory {
            type Client = DocumentProcessorService;
            type Credentials = gaxi::options::Credentials;
            async fn build(
                self,
                config: gaxi::options::ClientConfig,
            ) -> crate::ClientBuilderResult<Self::Client> {
                Self::Client::new(config).await
            }
        }
    }

    /// Common implementation for [crate::client::DocumentProcessorService] request builders.
    #[derive(Clone, Debug)]
    pub(crate) struct RequestBuilder<R: std::default::Default> {
        stub: std::sync::Arc<dyn super::super::stub::dynamic::DocumentProcessorService>,
        request: R,
        options: crate::RequestOptions,
    }

    impl<R> RequestBuilder<R>
    where
        R: std::default::Default,
    {
        pub(crate) fn new(
            stub: std::sync::Arc<dyn super::super::stub::dynamic::DocumentProcessorService>,
        ) -> Self {
            Self {
                stub,
                request: R::default(),
                options: crate::RequestOptions::default(),
            }
        }
    }

    /// The request builder for [DocumentProcessorService::process_document][crate::client::DocumentProcessorService::process_document] calls.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_documentai_v1::builder::document_processor_service::ProcessDocument;
    /// # async fn sample() -> google_cloud_documentai_v1::Result<()> {
    ///
    /// let builder = prepare_request_builder();
    /// let response = builder.send().await?;
    /// # Ok(()) }
    ///
    /// fn prepare_request_builder() -> ProcessDocument {
    ///   # panic!();
    ///   // ... details omitted ...
    /// }
    /// ```
    #[derive(Clone, Debug)]
    pub struct ProcessDocument(RequestBuilder<crate::model::ProcessRequest>);

    impl ProcessDocument {
        pub(crate) fn new(
            stub: std::sync::Arc<dyn super::super::stub::dynamic::DocumentProcessorService>,
        ) -> Self {
            Self(RequestBuilder::new(stub))
        }

        /// Sets the full request, replacing any prior values.
        pub fn with_request<V: Into<crate::model::ProcessRequest>>(mut self, v: V) -> Self {
            self.0.request = v.into();
            self
        }

        /// Sets all the options, replacing any prior values.
        pub fn with_options<V: Into<crate::RequestOptions>>(mut self, v: V) -> Self {
            self.0.options = v.into();
            self
        }

        /// Sends the request.
        pub async fn send(self) -> Result<crate::model::ProcessResponse> {
            (*self.0.stub)
                .process_document(self.0.request, self.0.options)
                .await
                .map(crate::Response::into_body)
        }

        /// Sets the value of [name][crate::model::ProcessRequest::name].
        ///
        /// This is a **required** field for requests.
        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
            self.0.request.name = v.into();
            self
        }

        /// Sets the value of [skip_human_review][crate::model::ProcessRequest::skip_human_review].
        pub fn set_skip_human_review<T: Into<bool>>(mut self, v: T) -> Self {
            self.0.request.skip_human_review = v.into();
            self
        }

        /// Sets the value of [field_mask][crate::model::ProcessRequest::field_mask].
        pub fn set_field_mask<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<wkt::FieldMask>,
        {
            self.0.request.field_mask = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [field_mask][crate::model::ProcessRequest::field_mask].
        pub fn set_or_clear_field_mask<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<wkt::FieldMask>,
        {
            self.0.request.field_mask = v.map(|x| x.into());
            self
        }

        /// Sets the value of [process_options][crate::model::ProcessRequest::process_options].
        pub fn set_process_options<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<crate::model::ProcessOptions>,
        {
            self.0.request.process_options = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [process_options][crate::model::ProcessRequest::process_options].
        pub fn set_or_clear_process_options<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<crate::model::ProcessOptions>,
        {
            self.0.request.process_options = v.map(|x| x.into());
            self
        }

        /// Sets the value of [labels][crate::model::ProcessRequest::labels].
        pub fn set_labels<T, K, V>(mut self, v: T) -> Self
        where
            T: std::iter::IntoIterator<Item = (K, V)>,
            K: std::convert::Into<std::string::String>,
            V: std::convert::Into<std::string::String>,
        {
            self.0.request.labels = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
            self
        }

        /// Sets the value of [imageless_mode][crate::model::ProcessRequest::imageless_mode].
        pub fn set_imageless_mode<T: Into<bool>>(mut self, v: T) -> Self {
            self.0.request.imageless_mode = v.into();
            self
        }

        /// Sets the value of [source][crate::model::ProcessRequest::source].
        ///
        /// Note that all the setters affecting `source` are
        /// mutually exclusive.
        pub fn set_source<T: Into<Option<crate::model::process_request::Source>>>(
            mut self,
            v: T,
        ) -> Self {
            self.0.request.source = v.into();
            self
        }

        /// Sets the value of [source][crate::model::ProcessRequest::source]
        /// to hold a `InlineDocument`.
        ///
        /// Note that all the setters affecting `source` are
        /// mutually exclusive.
        pub fn set_inline_document<
            T: std::convert::Into<std::boxed::Box<crate::model::Document>>,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.0.request = self.0.request.set_inline_document(v);
            self
        }

        /// Sets the value of [source][crate::model::ProcessRequest::source]
        /// to hold a `RawDocument`.
        ///
        /// Note that all the setters affecting `source` are
        /// mutually exclusive.
        pub fn set_raw_document<
            T: std::convert::Into<std::boxed::Box<crate::model::RawDocument>>,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.0.request = self.0.request.set_raw_document(v);
            self
        }

        /// Sets the value of [source][crate::model::ProcessRequest::source]
        /// to hold a `GcsDocument`.
        ///
        /// Note that all the setters affecting `source` are
        /// mutually exclusive.
        pub fn set_gcs_document<
            T: std::convert::Into<std::boxed::Box<crate::model::GcsDocument>>,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.0.request = self.0.request.set_gcs_document(v);
            self
        }
    }

    #[doc(hidden)]
    impl crate::RequestBuilder for ProcessDocument {
        fn request_options(&mut self) -> &mut crate::RequestOptions {
            &mut self.0.options
        }
    }

    /// The request builder for [DocumentProcessorService::batch_process_documents][crate::client::DocumentProcessorService::batch_process_documents] calls.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_documentai_v1::builder::document_processor_service::BatchProcessDocuments;
    /// # async fn sample() -> google_cloud_documentai_v1::Result<()> {
    /// use google_cloud_lro::Poller;
    ///
    /// let builder = prepare_request_builder();
    /// let response = builder.poller().until_done().await?;
    /// # Ok(()) }
    ///
    /// fn prepare_request_builder() -> BatchProcessDocuments {
    ///   # panic!();
    ///   // ... details omitted ...
    /// }
    /// ```
    #[derive(Clone, Debug)]
    pub struct BatchProcessDocuments(RequestBuilder<crate::model::BatchProcessRequest>);

    impl BatchProcessDocuments {
        pub(crate) fn new(
            stub: std::sync::Arc<dyn super::super::stub::dynamic::DocumentProcessorService>,
        ) -> Self {
            Self(RequestBuilder::new(stub))
        }

        /// Sets the full request, replacing any prior values.
        pub fn with_request<V: Into<crate::model::BatchProcessRequest>>(mut self, v: V) -> Self {
            self.0.request = v.into();
            self
        }

        /// Sets all the options, replacing any prior values.
        pub fn with_options<V: Into<crate::RequestOptions>>(mut self, v: V) -> Self {
            self.0.options = v.into();
            self
        }

        /// Sends the request.
        ///
        /// # Long running operations
        ///
        /// This starts, but does not poll, a longrunning operation. More information
        /// on [batch_process_documents][crate::client::DocumentProcessorService::batch_process_documents].
        pub async fn send(self) -> Result<google_cloud_longrunning::model::Operation> {
            (*self.0.stub)
                .batch_process_documents(self.0.request, self.0.options)
                .await
                .map(crate::Response::into_body)
        }

        /// Creates a [Poller][google_cloud_lro::Poller] to work with `batch_process_documents`.
        pub fn poller(
            self,
        ) -> impl google_cloud_lro::Poller<
            crate::model::BatchProcessResponse,
            crate::model::BatchProcessMetadata,
        > {
            type Operation = google_cloud_lro::internal::Operation<
                crate::model::BatchProcessResponse,
                crate::model::BatchProcessMetadata,
            >;
            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
            let mut poller_options = self.0.stub.get_poller_options(&self.0.options);
            if let Some(ref mut details) = poller_options.tracing {
                details.method_name = "google_cloud_documentai_v1::client::DocumentProcessorService::batch_process_documents::until_done";
            }

            let stub = self.0.stub.clone();
            let mut options = self.0.options.clone();
            options.set_retry_policy(google_cloud_gax::retry_policy::NeverRetry);
            let query = move |name| {
                let stub = stub.clone();
                let options = options.clone();
                async {
                    let op = GetOperation::new(stub)
                        .set_name(name)
                        .with_options(options)
                        .send()
                        .await?;
                    Ok(Operation::new(op))
                }
            };

            let start = move || async {
                let op = self.send().await?;
                Ok(Operation::new(op))
            };

            use google_cloud_lro::internal::PollerExt;
            {
                google_cloud_lro::internal::new_poller(
                    polling_error_policy,
                    polling_backoff_policy,
                    start,
                    query,
                )
            }
            .with_options(poller_options)
        }

        /// Sets the value of [name][crate::model::BatchProcessRequest::name].
        ///
        /// This is a **required** field for requests.
        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
            self.0.request.name = v.into();
            self
        }

        /// Sets the value of [input_documents][crate::model::BatchProcessRequest::input_documents].
        pub fn set_input_documents<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<crate::model::BatchDocumentsInputConfig>,
        {
            self.0.request.input_documents = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [input_documents][crate::model::BatchProcessRequest::input_documents].
        pub fn set_or_clear_input_documents<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<crate::model::BatchDocumentsInputConfig>,
        {
            self.0.request.input_documents = v.map(|x| x.into());
            self
        }

        /// Sets the value of [document_output_config][crate::model::BatchProcessRequest::document_output_config].
        pub fn set_document_output_config<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<crate::model::DocumentOutputConfig>,
        {
            self.0.request.document_output_config = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [document_output_config][crate::model::BatchProcessRequest::document_output_config].
        pub fn set_or_clear_document_output_config<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<crate::model::DocumentOutputConfig>,
        {
            self.0.request.document_output_config = v.map(|x| x.into());
            self
        }

        /// Sets the value of [skip_human_review][crate::model::BatchProcessRequest::skip_human_review].
        pub fn set_skip_human_review<T: Into<bool>>(mut self, v: T) -> Self {
            self.0.request.skip_human_review = v.into();
            self
        }

        /// Sets the value of [process_options][crate::model::BatchProcessRequest::process_options].
        pub fn set_process_options<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<crate::model::ProcessOptions>,
        {
            self.0.request.process_options = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [process_options][crate::model::BatchProcessRequest::process_options].
        pub fn set_or_clear_process_options<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<crate::model::ProcessOptions>,
        {
            self.0.request.process_options = v.map(|x| x.into());
            self
        }

        /// Sets the value of [labels][crate::model::BatchProcessRequest::labels].
        pub fn set_labels<T, K, V>(mut self, v: T) -> Self
        where
            T: std::iter::IntoIterator<Item = (K, V)>,
            K: std::convert::Into<std::string::String>,
            V: std::convert::Into<std::string::String>,
        {
            self.0.request.labels = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
            self
        }
    }

    #[doc(hidden)]
    impl crate::RequestBuilder for BatchProcessDocuments {
        fn request_options(&mut self) -> &mut crate::RequestOptions {
            &mut self.0.options
        }
    }

    /// The request builder for [DocumentProcessorService::fetch_processor_types][crate::client::DocumentProcessorService::fetch_processor_types] calls.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_documentai_v1::builder::document_processor_service::FetchProcessorTypes;
    /// # async fn sample() -> google_cloud_documentai_v1::Result<()> {
    ///
    /// let builder = prepare_request_builder();
    /// let response = builder.send().await?;
    /// # Ok(()) }
    ///
    /// fn prepare_request_builder() -> FetchProcessorTypes {
    ///   # panic!();
    ///   // ... details omitted ...
    /// }
    /// ```
    #[derive(Clone, Debug)]
    pub struct FetchProcessorTypes(RequestBuilder<crate::model::FetchProcessorTypesRequest>);

    impl FetchProcessorTypes {
        pub(crate) fn new(
            stub: std::sync::Arc<dyn super::super::stub::dynamic::DocumentProcessorService>,
        ) -> Self {
            Self(RequestBuilder::new(stub))
        }

        /// Sets the full request, replacing any prior values.
        pub fn with_request<V: Into<crate::model::FetchProcessorTypesRequest>>(
            mut self,
            v: V,
        ) -> Self {
            self.0.request = v.into();
            self
        }

        /// Sets all the options, replacing any prior values.
        pub fn with_options<V: Into<crate::RequestOptions>>(mut self, v: V) -> Self {
            self.0.options = v.into();
            self
        }

        /// Sends the request.
        pub async fn send(self) -> Result<crate::model::FetchProcessorTypesResponse> {
            (*self.0.stub)
                .fetch_processor_types(self.0.request, self.0.options)
                .await
                .map(crate::Response::into_body)
        }

        /// Sets the value of [parent][crate::model::FetchProcessorTypesRequest::parent].
        ///
        /// This is a **required** field for requests.
        pub fn set_parent<T: Into<std::string::String>>(mut self, v: T) -> Self {
            self.0.request.parent = v.into();
            self
        }
    }

    #[doc(hidden)]
    impl crate::RequestBuilder for FetchProcessorTypes {
        fn request_options(&mut self) -> &mut crate::RequestOptions {
            &mut self.0.options
        }
    }

    /// The request builder for [DocumentProcessorService::list_processor_types][crate::client::DocumentProcessorService::list_processor_types] calls.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_documentai_v1::builder::document_processor_service::ListProcessorTypes;
    /// # async fn sample() -> google_cloud_documentai_v1::Result<()> {
    /// use google_cloud_gax::paginator::ItemPaginator;
    ///
    /// let builder = prepare_request_builder();
    /// let mut items = builder.by_item();
    /// while let Some(result) = items.next().await {
    ///   let item = result?;
    /// }
    /// # Ok(()) }
    ///
    /// fn prepare_request_builder() -> ListProcessorTypes {
    ///   # panic!();
    ///   // ... details omitted ...
    /// }
    /// ```
    #[derive(Clone, Debug)]
    pub struct ListProcessorTypes(RequestBuilder<crate::model::ListProcessorTypesRequest>);

    impl ListProcessorTypes {
        pub(crate) fn new(
            stub: std::sync::Arc<dyn super::super::stub::dynamic::DocumentProcessorService>,
        ) -> Self {
            Self(RequestBuilder::new(stub))
        }

        /// Sets the full request, replacing any prior values.
        pub fn with_request<V: Into<crate::model::ListProcessorTypesRequest>>(
            mut self,
            v: V,
        ) -> Self {
            self.0.request = v.into();
            self
        }

        /// Sets all the options, replacing any prior values.
        pub fn with_options<V: Into<crate::RequestOptions>>(mut self, v: V) -> Self {
            self.0.options = v.into();
            self
        }

        /// Sends the request.
        pub async fn send(self) -> Result<crate::model::ListProcessorTypesResponse> {
            (*self.0.stub)
                .list_processor_types(self.0.request, self.0.options)
                .await
                .map(crate::Response::into_body)
        }

        /// Streams each page in the collection.
        pub fn by_page(
            self,
        ) -> impl google_cloud_gax::paginator::Paginator<
            crate::model::ListProcessorTypesResponse,
            crate::Error,
        > {
            use std::clone::Clone;
            let token = self.0.request.page_token.clone();
            let execute = move |token: String| {
                let mut builder = self.clone();
                builder.0.request = builder.0.request.set_page_token(token);
                builder.send()
            };
            google_cloud_gax::paginator::internal::new_paginator(token, execute)
        }

        /// Streams each item in the collection.
        pub fn by_item(
            self,
        ) -> impl google_cloud_gax::paginator::ItemPaginator<
            crate::model::ListProcessorTypesResponse,
            crate::Error,
        > {
            use google_cloud_gax::paginator::Paginator;
            self.by_page().items()
        }

        /// Sets the value of [parent][crate::model::ListProcessorTypesRequest::parent].
        ///
        /// This is a **required** field for requests.
        pub fn set_parent<T: Into<std::string::String>>(mut self, v: T) -> Self {
            self.0.request.parent = v.into();
            self
        }

        /// Sets the value of [page_size][crate::model::ListProcessorTypesRequest::page_size].
        pub fn set_page_size<T: Into<i32>>(mut self, v: T) -> Self {
            self.0.request.page_size = v.into();
            self
        }

        /// Sets the value of [page_token][crate::model::ListProcessorTypesRequest::page_token].
        pub fn set_page_token<T: Into<std::string::String>>(mut self, v: T) -> Self {
            self.0.request.page_token = v.into();
            self
        }
    }

    #[doc(hidden)]
    impl crate::RequestBuilder for ListProcessorTypes {
        fn request_options(&mut self) -> &mut crate::RequestOptions {
            &mut self.0.options
        }
    }

    /// The request builder for [DocumentProcessorService::get_processor_type][crate::client::DocumentProcessorService::get_processor_type] calls.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_documentai_v1::builder::document_processor_service::GetProcessorType;
    /// # async fn sample() -> google_cloud_documentai_v1::Result<()> {
    ///
    /// let builder = prepare_request_builder();
    /// let response = builder.send().await?;
    /// # Ok(()) }
    ///
    /// fn prepare_request_builder() -> GetProcessorType {
    ///   # panic!();
    ///   // ... details omitted ...
    /// }
    /// ```
    #[derive(Clone, Debug)]
    pub struct GetProcessorType(RequestBuilder<crate::model::GetProcessorTypeRequest>);

    impl GetProcessorType {
        pub(crate) fn new(
            stub: std::sync::Arc<dyn super::super::stub::dynamic::DocumentProcessorService>,
        ) -> Self {
            Self(RequestBuilder::new(stub))
        }

        /// Sets the full request, replacing any prior values.
        pub fn with_request<V: Into<crate::model::GetProcessorTypeRequest>>(
            mut self,
            v: V,
        ) -> Self {
            self.0.request = v.into();
            self
        }

        /// Sets all the options, replacing any prior values.
        pub fn with_options<V: Into<crate::RequestOptions>>(mut self, v: V) -> Self {
            self.0.options = v.into();
            self
        }

        /// Sends the request.
        pub async fn send(self) -> Result<crate::model::ProcessorType> {
            (*self.0.stub)
                .get_processor_type(self.0.request, self.0.options)
                .await
                .map(crate::Response::into_body)
        }

        /// Sets the value of [name][crate::model::GetProcessorTypeRequest::name].
        ///
        /// This is a **required** field for requests.
        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
            self.0.request.name = v.into();
            self
        }
    }

    #[doc(hidden)]
    impl crate::RequestBuilder for GetProcessorType {
        fn request_options(&mut self) -> &mut crate::RequestOptions {
            &mut self.0.options
        }
    }

    /// The request builder for [DocumentProcessorService::list_processors][crate::client::DocumentProcessorService::list_processors] calls.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_documentai_v1::builder::document_processor_service::ListProcessors;
    /// # async fn sample() -> google_cloud_documentai_v1::Result<()> {
    /// use google_cloud_gax::paginator::ItemPaginator;
    ///
    /// let builder = prepare_request_builder();
    /// let mut items = builder.by_item();
    /// while let Some(result) = items.next().await {
    ///   let item = result?;
    /// }
    /// # Ok(()) }
    ///
    /// fn prepare_request_builder() -> ListProcessors {
    ///   # panic!();
    ///   // ... details omitted ...
    /// }
    /// ```
    #[derive(Clone, Debug)]
    pub struct ListProcessors(RequestBuilder<crate::model::ListProcessorsRequest>);

    impl ListProcessors {
        pub(crate) fn new(
            stub: std::sync::Arc<dyn super::super::stub::dynamic::DocumentProcessorService>,
        ) -> Self {
            Self(RequestBuilder::new(stub))
        }

        /// Sets the full request, replacing any prior values.
        pub fn with_request<V: Into<crate::model::ListProcessorsRequest>>(mut self, v: V) -> Self {
            self.0.request = v.into();
            self
        }

        /// Sets all the options, replacing any prior values.
        pub fn with_options<V: Into<crate::RequestOptions>>(mut self, v: V) -> Self {
            self.0.options = v.into();
            self
        }

        /// Sends the request.
        pub async fn send(self) -> Result<crate::model::ListProcessorsResponse> {
            (*self.0.stub)
                .list_processors(self.0.request, self.0.options)
                .await
                .map(crate::Response::into_body)
        }

        /// Streams each page in the collection.
        pub fn by_page(
            self,
        ) -> impl google_cloud_gax::paginator::Paginator<
            crate::model::ListProcessorsResponse,
            crate::Error,
        > {
            use std::clone::Clone;
            let token = self.0.request.page_token.clone();
            let execute = move |token: String| {
                let mut builder = self.clone();
                builder.0.request = builder.0.request.set_page_token(token);
                builder.send()
            };
            google_cloud_gax::paginator::internal::new_paginator(token, execute)
        }

        /// Streams each item in the collection.
        pub fn by_item(
            self,
        ) -> impl google_cloud_gax::paginator::ItemPaginator<
            crate::model::ListProcessorsResponse,
            crate::Error,
        > {
            use google_cloud_gax::paginator::Paginator;
            self.by_page().items()
        }

        /// Sets the value of [parent][crate::model::ListProcessorsRequest::parent].
        ///
        /// This is a **required** field for requests.
        pub fn set_parent<T: Into<std::string::String>>(mut self, v: T) -> Self {
            self.0.request.parent = v.into();
            self
        }

        /// Sets the value of [page_size][crate::model::ListProcessorsRequest::page_size].
        pub fn set_page_size<T: Into<i32>>(mut self, v: T) -> Self {
            self.0.request.page_size = v.into();
            self
        }

        /// Sets the value of [page_token][crate::model::ListProcessorsRequest::page_token].
        pub fn set_page_token<T: Into<std::string::String>>(mut self, v: T) -> Self {
            self.0.request.page_token = v.into();
            self
        }
    }

    #[doc(hidden)]
    impl crate::RequestBuilder for ListProcessors {
        fn request_options(&mut self) -> &mut crate::RequestOptions {
            &mut self.0.options
        }
    }

    /// The request builder for [DocumentProcessorService::get_processor][crate::client::DocumentProcessorService::get_processor] calls.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_documentai_v1::builder::document_processor_service::GetProcessor;
    /// # async fn sample() -> google_cloud_documentai_v1::Result<()> {
    ///
    /// let builder = prepare_request_builder();
    /// let response = builder.send().await?;
    /// # Ok(()) }
    ///
    /// fn prepare_request_builder() -> GetProcessor {
    ///   # panic!();
    ///   // ... details omitted ...
    /// }
    /// ```
    #[derive(Clone, Debug)]
    pub struct GetProcessor(RequestBuilder<crate::model::GetProcessorRequest>);

    impl GetProcessor {
        pub(crate) fn new(
            stub: std::sync::Arc<dyn super::super::stub::dynamic::DocumentProcessorService>,
        ) -> Self {
            Self(RequestBuilder::new(stub))
        }

        /// Sets the full request, replacing any prior values.
        pub fn with_request<V: Into<crate::model::GetProcessorRequest>>(mut self, v: V) -> Self {
            self.0.request = v.into();
            self
        }

        /// Sets all the options, replacing any prior values.
        pub fn with_options<V: Into<crate::RequestOptions>>(mut self, v: V) -> Self {
            self.0.options = v.into();
            self
        }

        /// Sends the request.
        pub async fn send(self) -> Result<crate::model::Processor> {
            (*self.0.stub)
                .get_processor(self.0.request, self.0.options)
                .await
                .map(crate::Response::into_body)
        }

        /// Sets the value of [name][crate::model::GetProcessorRequest::name].
        ///
        /// This is a **required** field for requests.
        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
            self.0.request.name = v.into();
            self
        }
    }

    #[doc(hidden)]
    impl crate::RequestBuilder for GetProcessor {
        fn request_options(&mut self) -> &mut crate::RequestOptions {
            &mut self.0.options
        }
    }

    /// The request builder for [DocumentProcessorService::train_processor_version][crate::client::DocumentProcessorService::train_processor_version] calls.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_documentai_v1::builder::document_processor_service::TrainProcessorVersion;
    /// # async fn sample() -> google_cloud_documentai_v1::Result<()> {
    /// use google_cloud_lro::Poller;
    ///
    /// let builder = prepare_request_builder();
    /// let response = builder.poller().until_done().await?;
    /// # Ok(()) }
    ///
    /// fn prepare_request_builder() -> TrainProcessorVersion {
    ///   # panic!();
    ///   // ... details omitted ...
    /// }
    /// ```
    #[derive(Clone, Debug)]
    pub struct TrainProcessorVersion(RequestBuilder<crate::model::TrainProcessorVersionRequest>);

    impl TrainProcessorVersion {
        pub(crate) fn new(
            stub: std::sync::Arc<dyn super::super::stub::dynamic::DocumentProcessorService>,
        ) -> Self {
            Self(RequestBuilder::new(stub))
        }

        /// Sets the full request, replacing any prior values.
        pub fn with_request<V: Into<crate::model::TrainProcessorVersionRequest>>(
            mut self,
            v: V,
        ) -> Self {
            self.0.request = v.into();
            self
        }

        /// Sets all the options, replacing any prior values.
        pub fn with_options<V: Into<crate::RequestOptions>>(mut self, v: V) -> Self {
            self.0.options = v.into();
            self
        }

        /// Sends the request.
        ///
        /// # Long running operations
        ///
        /// This starts, but does not poll, a longrunning operation. More information
        /// on [train_processor_version][crate::client::DocumentProcessorService::train_processor_version].
        pub async fn send(self) -> Result<google_cloud_longrunning::model::Operation> {
            (*self.0.stub)
                .train_processor_version(self.0.request, self.0.options)
                .await
                .map(crate::Response::into_body)
        }

        /// Creates a [Poller][google_cloud_lro::Poller] to work with `train_processor_version`.
        pub fn poller(
            self,
        ) -> impl google_cloud_lro::Poller<
            crate::model::TrainProcessorVersionResponse,
            crate::model::TrainProcessorVersionMetadata,
        > {
            type Operation = google_cloud_lro::internal::Operation<
                crate::model::TrainProcessorVersionResponse,
                crate::model::TrainProcessorVersionMetadata,
            >;
            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
            let mut poller_options = self.0.stub.get_poller_options(&self.0.options);
            if let Some(ref mut details) = poller_options.tracing {
                details.method_name = "google_cloud_documentai_v1::client::DocumentProcessorService::train_processor_version::until_done";
            }

            let stub = self.0.stub.clone();
            let mut options = self.0.options.clone();
            options.set_retry_policy(google_cloud_gax::retry_policy::NeverRetry);
            let query = move |name| {
                let stub = stub.clone();
                let options = options.clone();
                async {
                    let op = GetOperation::new(stub)
                        .set_name(name)
                        .with_options(options)
                        .send()
                        .await?;
                    Ok(Operation::new(op))
                }
            };

            let start = move || async {
                let op = self.send().await?;
                Ok(Operation::new(op))
            };

            use google_cloud_lro::internal::PollerExt;
            {
                google_cloud_lro::internal::new_poller(
                    polling_error_policy,
                    polling_backoff_policy,
                    start,
                    query,
                )
            }
            .with_options(poller_options)
        }

        /// Sets the value of [parent][crate::model::TrainProcessorVersionRequest::parent].
        ///
        /// This is a **required** field for requests.
        pub fn set_parent<T: Into<std::string::String>>(mut self, v: T) -> Self {
            self.0.request.parent = v.into();
            self
        }

        /// Sets the value of [processor_version][crate::model::TrainProcessorVersionRequest::processor_version].
        ///
        /// This is a **required** field for requests.
        pub fn set_processor_version<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<crate::model::ProcessorVersion>,
        {
            self.0.request.processor_version = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [processor_version][crate::model::TrainProcessorVersionRequest::processor_version].
        ///
        /// This is a **required** field for requests.
        pub fn set_or_clear_processor_version<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<crate::model::ProcessorVersion>,
        {
            self.0.request.processor_version = v.map(|x| x.into());
            self
        }

        /// Sets the value of [document_schema][crate::model::TrainProcessorVersionRequest::document_schema].
        pub fn set_document_schema<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<crate::model::DocumentSchema>,
        {
            self.0.request.document_schema = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [document_schema][crate::model::TrainProcessorVersionRequest::document_schema].
        pub fn set_or_clear_document_schema<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<crate::model::DocumentSchema>,
        {
            self.0.request.document_schema = v.map(|x| x.into());
            self
        }

        /// Sets the value of [input_data][crate::model::TrainProcessorVersionRequest::input_data].
        pub fn set_input_data<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<crate::model::train_processor_version_request::InputData>,
        {
            self.0.request.input_data = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [input_data][crate::model::TrainProcessorVersionRequest::input_data].
        pub fn set_or_clear_input_data<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<crate::model::train_processor_version_request::InputData>,
        {
            self.0.request.input_data = v.map(|x| x.into());
            self
        }

        /// Sets the value of [base_processor_version][crate::model::TrainProcessorVersionRequest::base_processor_version].
        pub fn set_base_processor_version<T: Into<std::string::String>>(mut self, v: T) -> Self {
            self.0.request.base_processor_version = v.into();
            self
        }

        /// Sets the value of [processor_flags][crate::model::TrainProcessorVersionRequest::processor_flags].
        ///
        /// Note that all the setters affecting `processor_flags` are
        /// mutually exclusive.
        pub fn set_processor_flags<
            T: Into<Option<crate::model::train_processor_version_request::ProcessorFlags>>,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.0.request.processor_flags = v.into();
            self
        }

        /// Sets the value of [processor_flags][crate::model::TrainProcessorVersionRequest::processor_flags]
        /// to hold a `CustomDocumentExtractionOptions`.
        ///
        /// Note that all the setters affecting `processor_flags` are
        /// mutually exclusive.
        pub fn set_custom_document_extraction_options<T: std::convert::Into<std::boxed::Box<crate::model::train_processor_version_request::CustomDocumentExtractionOptions>>>(mut self, v: T) -> Self{
            self.0.request = self.0.request.set_custom_document_extraction_options(v);
            self
        }

        /// Sets the value of [processor_flags][crate::model::TrainProcessorVersionRequest::processor_flags]
        /// to hold a `FoundationModelTuningOptions`.
        ///
        /// Note that all the setters affecting `processor_flags` are
        /// mutually exclusive.
        pub fn set_foundation_model_tuning_options<
            T: std::convert::Into<
                    std::boxed::Box<
                        crate::model::train_processor_version_request::FoundationModelTuningOptions,
                    >,
                >,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.0.request = self.0.request.set_foundation_model_tuning_options(v);
            self
        }
    }

    #[doc(hidden)]
    impl crate::RequestBuilder for TrainProcessorVersion {
        fn request_options(&mut self) -> &mut crate::RequestOptions {
            &mut self.0.options
        }
    }

    /// The request builder for [DocumentProcessorService::get_processor_version][crate::client::DocumentProcessorService::get_processor_version] calls.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_documentai_v1::builder::document_processor_service::GetProcessorVersion;
    /// # async fn sample() -> google_cloud_documentai_v1::Result<()> {
    ///
    /// let builder = prepare_request_builder();
    /// let response = builder.send().await?;
    /// # Ok(()) }
    ///
    /// fn prepare_request_builder() -> GetProcessorVersion {
    ///   # panic!();
    ///   // ... details omitted ...
    /// }
    /// ```
    #[derive(Clone, Debug)]
    pub struct GetProcessorVersion(RequestBuilder<crate::model::GetProcessorVersionRequest>);

    impl GetProcessorVersion {
        pub(crate) fn new(
            stub: std::sync::Arc<dyn super::super::stub::dynamic::DocumentProcessorService>,
        ) -> Self {
            Self(RequestBuilder::new(stub))
        }

        /// Sets the full request, replacing any prior values.
        pub fn with_request<V: Into<crate::model::GetProcessorVersionRequest>>(
            mut self,
            v: V,
        ) -> Self {
            self.0.request = v.into();
            self
        }

        /// Sets all the options, replacing any prior values.
        pub fn with_options<V: Into<crate::RequestOptions>>(mut self, v: V) -> Self {
            self.0.options = v.into();
            self
        }

        /// Sends the request.
        pub async fn send(self) -> Result<crate::model::ProcessorVersion> {
            (*self.0.stub)
                .get_processor_version(self.0.request, self.0.options)
                .await
                .map(crate::Response::into_body)
        }

        /// Sets the value of [name][crate::model::GetProcessorVersionRequest::name].
        ///
        /// This is a **required** field for requests.
        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
            self.0.request.name = v.into();
            self
        }
    }

    #[doc(hidden)]
    impl crate::RequestBuilder for GetProcessorVersion {
        fn request_options(&mut self) -> &mut crate::RequestOptions {
            &mut self.0.options
        }
    }

    /// The request builder for [DocumentProcessorService::list_processor_versions][crate::client::DocumentProcessorService::list_processor_versions] calls.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_documentai_v1::builder::document_processor_service::ListProcessorVersions;
    /// # async fn sample() -> google_cloud_documentai_v1::Result<()> {
    /// use google_cloud_gax::paginator::ItemPaginator;
    ///
    /// let builder = prepare_request_builder();
    /// let mut items = builder.by_item();
    /// while let Some(result) = items.next().await {
    ///   let item = result?;
    /// }
    /// # Ok(()) }
    ///
    /// fn prepare_request_builder() -> ListProcessorVersions {
    ///   # panic!();
    ///   // ... details omitted ...
    /// }
    /// ```
    #[derive(Clone, Debug)]
    pub struct ListProcessorVersions(RequestBuilder<crate::model::ListProcessorVersionsRequest>);

    impl ListProcessorVersions {
        pub(crate) fn new(
            stub: std::sync::Arc<dyn super::super::stub::dynamic::DocumentProcessorService>,
        ) -> Self {
            Self(RequestBuilder::new(stub))
        }

        /// Sets the full request, replacing any prior values.
        pub fn with_request<V: Into<crate::model::ListProcessorVersionsRequest>>(
            mut self,
            v: V,
        ) -> Self {
            self.0.request = v.into();
            self
        }

        /// Sets all the options, replacing any prior values.
        pub fn with_options<V: Into<crate::RequestOptions>>(mut self, v: V) -> Self {
            self.0.options = v.into();
            self
        }

        /// Sends the request.
        pub async fn send(self) -> Result<crate::model::ListProcessorVersionsResponse> {
            (*self.0.stub)
                .list_processor_versions(self.0.request, self.0.options)
                .await
                .map(crate::Response::into_body)
        }

        /// Streams each page in the collection.
        pub fn by_page(
            self,
        ) -> impl google_cloud_gax::paginator::Paginator<
            crate::model::ListProcessorVersionsResponse,
            crate::Error,
        > {
            use std::clone::Clone;
            let token = self.0.request.page_token.clone();
            let execute = move |token: String| {
                let mut builder = self.clone();
                builder.0.request = builder.0.request.set_page_token(token);
                builder.send()
            };
            google_cloud_gax::paginator::internal::new_paginator(token, execute)
        }

        /// Streams each item in the collection.
        pub fn by_item(
            self,
        ) -> impl google_cloud_gax::paginator::ItemPaginator<
            crate::model::ListProcessorVersionsResponse,
            crate::Error,
        > {
            use google_cloud_gax::paginator::Paginator;
            self.by_page().items()
        }

        /// Sets the value of [parent][crate::model::ListProcessorVersionsRequest::parent].
        ///
        /// This is a **required** field for requests.
        pub fn set_parent<T: Into<std::string::String>>(mut self, v: T) -> Self {
            self.0.request.parent = v.into();
            self
        }

        /// Sets the value of [page_size][crate::model::ListProcessorVersionsRequest::page_size].
        pub fn set_page_size<T: Into<i32>>(mut self, v: T) -> Self {
            self.0.request.page_size = v.into();
            self
        }

        /// Sets the value of [page_token][crate::model::ListProcessorVersionsRequest::page_token].
        pub fn set_page_token<T: Into<std::string::String>>(mut self, v: T) -> Self {
            self.0.request.page_token = v.into();
            self
        }
    }

    #[doc(hidden)]
    impl crate::RequestBuilder for ListProcessorVersions {
        fn request_options(&mut self) -> &mut crate::RequestOptions {
            &mut self.0.options
        }
    }

    /// The request builder for [DocumentProcessorService::delete_processor_version][crate::client::DocumentProcessorService::delete_processor_version] calls.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_documentai_v1::builder::document_processor_service::DeleteProcessorVersion;
    /// # async fn sample() -> google_cloud_documentai_v1::Result<()> {
    /// use google_cloud_lro::Poller;
    ///
    /// let builder = prepare_request_builder();
    /// let response = builder.poller().until_done().await?;
    /// # Ok(()) }
    ///
    /// fn prepare_request_builder() -> DeleteProcessorVersion {
    ///   # panic!();
    ///   // ... details omitted ...
    /// }
    /// ```
    #[derive(Clone, Debug)]
    pub struct DeleteProcessorVersion(RequestBuilder<crate::model::DeleteProcessorVersionRequest>);

    impl DeleteProcessorVersion {
        pub(crate) fn new(
            stub: std::sync::Arc<dyn super::super::stub::dynamic::DocumentProcessorService>,
        ) -> Self {
            Self(RequestBuilder::new(stub))
        }

        /// Sets the full request, replacing any prior values.
        pub fn with_request<V: Into<crate::model::DeleteProcessorVersionRequest>>(
            mut self,
            v: V,
        ) -> Self {
            self.0.request = v.into();
            self
        }

        /// Sets all the options, replacing any prior values.
        pub fn with_options<V: Into<crate::RequestOptions>>(mut self, v: V) -> Self {
            self.0.options = v.into();
            self
        }

        /// Sends the request.
        ///
        /// # Long running operations
        ///
        /// This starts, but does not poll, a longrunning operation. More information
        /// on [delete_processor_version][crate::client::DocumentProcessorService::delete_processor_version].
        pub async fn send(self) -> Result<google_cloud_longrunning::model::Operation> {
            (*self.0.stub)
                .delete_processor_version(self.0.request, self.0.options)
                .await
                .map(crate::Response::into_body)
        }

        /// Creates a [Poller][google_cloud_lro::Poller] to work with `delete_processor_version`.
        pub fn poller(
            self,
        ) -> impl google_cloud_lro::Poller<(), crate::model::DeleteProcessorVersionMetadata>
        {
            type Operation = google_cloud_lro::internal::Operation<
                wkt::Empty,
                crate::model::DeleteProcessorVersionMetadata,
            >;
            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
            let mut poller_options = self.0.stub.get_poller_options(&self.0.options);
            if let Some(ref mut details) = poller_options.tracing {
                details.method_name = "google_cloud_documentai_v1::client::DocumentProcessorService::delete_processor_version::until_done";
            }

            let stub = self.0.stub.clone();
            let mut options = self.0.options.clone();
            options.set_retry_policy(google_cloud_gax::retry_policy::NeverRetry);
            let query = move |name| {
                let stub = stub.clone();
                let options = options.clone();
                async {
                    let op = GetOperation::new(stub)
                        .set_name(name)
                        .with_options(options)
                        .send()
                        .await?;
                    Ok(Operation::new(op))
                }
            };

            let start = move || async {
                let op = self.send().await?;
                Ok(Operation::new(op))
            };

            use google_cloud_lro::internal::PollerExt;
            {
                google_cloud_lro::internal::new_unit_response_poller(
                    polling_error_policy,
                    polling_backoff_policy,
                    start,
                    query,
                )
            }
            .with_options(poller_options)
        }

        /// Sets the value of [name][crate::model::DeleteProcessorVersionRequest::name].
        ///
        /// This is a **required** field for requests.
        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
            self.0.request.name = v.into();
            self
        }
    }

    #[doc(hidden)]
    impl crate::RequestBuilder for DeleteProcessorVersion {
        fn request_options(&mut self) -> &mut crate::RequestOptions {
            &mut self.0.options
        }
    }

    /// The request builder for [DocumentProcessorService::deploy_processor_version][crate::client::DocumentProcessorService::deploy_processor_version] calls.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_documentai_v1::builder::document_processor_service::DeployProcessorVersion;
    /// # async fn sample() -> google_cloud_documentai_v1::Result<()> {
    /// use google_cloud_lro::Poller;
    ///
    /// let builder = prepare_request_builder();
    /// let response = builder.poller().until_done().await?;
    /// # Ok(()) }
    ///
    /// fn prepare_request_builder() -> DeployProcessorVersion {
    ///   # panic!();
    ///   // ... details omitted ...
    /// }
    /// ```
    #[derive(Clone, Debug)]
    pub struct DeployProcessorVersion(RequestBuilder<crate::model::DeployProcessorVersionRequest>);

    impl DeployProcessorVersion {
        pub(crate) fn new(
            stub: std::sync::Arc<dyn super::super::stub::dynamic::DocumentProcessorService>,
        ) -> Self {
            Self(RequestBuilder::new(stub))
        }

        /// Sets the full request, replacing any prior values.
        pub fn with_request<V: Into<crate::model::DeployProcessorVersionRequest>>(
            mut self,
            v: V,
        ) -> Self {
            self.0.request = v.into();
            self
        }

        /// Sets all the options, replacing any prior values.
        pub fn with_options<V: Into<crate::RequestOptions>>(mut self, v: V) -> Self {
            self.0.options = v.into();
            self
        }

        /// Sends the request.
        ///
        /// # Long running operations
        ///
        /// This starts, but does not poll, a longrunning operation. More information
        /// on [deploy_processor_version][crate::client::DocumentProcessorService::deploy_processor_version].
        pub async fn send(self) -> Result<google_cloud_longrunning::model::Operation> {
            (*self.0.stub)
                .deploy_processor_version(self.0.request, self.0.options)
                .await
                .map(crate::Response::into_body)
        }

        /// Creates a [Poller][google_cloud_lro::Poller] to work with `deploy_processor_version`.
        pub fn poller(
            self,
        ) -> impl google_cloud_lro::Poller<
            crate::model::DeployProcessorVersionResponse,
            crate::model::DeployProcessorVersionMetadata,
        > {
            type Operation = google_cloud_lro::internal::Operation<
                crate::model::DeployProcessorVersionResponse,
                crate::model::DeployProcessorVersionMetadata,
            >;
            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
            let mut poller_options = self.0.stub.get_poller_options(&self.0.options);
            if let Some(ref mut details) = poller_options.tracing {
                details.method_name = "google_cloud_documentai_v1::client::DocumentProcessorService::deploy_processor_version::until_done";
            }

            let stub = self.0.stub.clone();
            let mut options = self.0.options.clone();
            options.set_retry_policy(google_cloud_gax::retry_policy::NeverRetry);
            let query = move |name| {
                let stub = stub.clone();
                let options = options.clone();
                async {
                    let op = GetOperation::new(stub)
                        .set_name(name)
                        .with_options(options)
                        .send()
                        .await?;
                    Ok(Operation::new(op))
                }
            };

            let start = move || async {
                let op = self.send().await?;
                Ok(Operation::new(op))
            };

            use google_cloud_lro::internal::PollerExt;
            {
                google_cloud_lro::internal::new_poller(
                    polling_error_policy,
                    polling_backoff_policy,
                    start,
                    query,
                )
            }
            .with_options(poller_options)
        }

        /// Sets the value of [name][crate::model::DeployProcessorVersionRequest::name].
        ///
        /// This is a **required** field for requests.
        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
            self.0.request.name = v.into();
            self
        }
    }

    #[doc(hidden)]
    impl crate::RequestBuilder for DeployProcessorVersion {
        fn request_options(&mut self) -> &mut crate::RequestOptions {
            &mut self.0.options
        }
    }

    /// The request builder for [DocumentProcessorService::undeploy_processor_version][crate::client::DocumentProcessorService::undeploy_processor_version] calls.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_documentai_v1::builder::document_processor_service::UndeployProcessorVersion;
    /// # async fn sample() -> google_cloud_documentai_v1::Result<()> {
    /// use google_cloud_lro::Poller;
    ///
    /// let builder = prepare_request_builder();
    /// let response = builder.poller().until_done().await?;
    /// # Ok(()) }
    ///
    /// fn prepare_request_builder() -> UndeployProcessorVersion {
    ///   # panic!();
    ///   // ... details omitted ...
    /// }
    /// ```
    #[derive(Clone, Debug)]
    pub struct UndeployProcessorVersion(
        RequestBuilder<crate::model::UndeployProcessorVersionRequest>,
    );

    impl UndeployProcessorVersion {
        pub(crate) fn new(
            stub: std::sync::Arc<dyn super::super::stub::dynamic::DocumentProcessorService>,
        ) -> Self {
            Self(RequestBuilder::new(stub))
        }

        /// Sets the full request, replacing any prior values.
        pub fn with_request<V: Into<crate::model::UndeployProcessorVersionRequest>>(
            mut self,
            v: V,
        ) -> Self {
            self.0.request = v.into();
            self
        }

        /// Sets all the options, replacing any prior values.
        pub fn with_options<V: Into<crate::RequestOptions>>(mut self, v: V) -> Self {
            self.0.options = v.into();
            self
        }

        /// Sends the request.
        ///
        /// # Long running operations
        ///
        /// This starts, but does not poll, a longrunning operation. More information
        /// on [undeploy_processor_version][crate::client::DocumentProcessorService::undeploy_processor_version].
        pub async fn send(self) -> Result<google_cloud_longrunning::model::Operation> {
            (*self.0.stub)
                .undeploy_processor_version(self.0.request, self.0.options)
                .await
                .map(crate::Response::into_body)
        }

        /// Creates a [Poller][google_cloud_lro::Poller] to work with `undeploy_processor_version`.
        pub fn poller(
            self,
        ) -> impl google_cloud_lro::Poller<
            crate::model::UndeployProcessorVersionResponse,
            crate::model::UndeployProcessorVersionMetadata,
        > {
            type Operation = google_cloud_lro::internal::Operation<
                crate::model::UndeployProcessorVersionResponse,
                crate::model::UndeployProcessorVersionMetadata,
            >;
            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
            let mut poller_options = self.0.stub.get_poller_options(&self.0.options);
            if let Some(ref mut details) = poller_options.tracing {
                details.method_name = "google_cloud_documentai_v1::client::DocumentProcessorService::undeploy_processor_version::until_done";
            }

            let stub = self.0.stub.clone();
            let mut options = self.0.options.clone();
            options.set_retry_policy(google_cloud_gax::retry_policy::NeverRetry);
            let query = move |name| {
                let stub = stub.clone();
                let options = options.clone();
                async {
                    let op = GetOperation::new(stub)
                        .set_name(name)
                        .with_options(options)
                        .send()
                        .await?;
                    Ok(Operation::new(op))
                }
            };

            let start = move || async {
                let op = self.send().await?;
                Ok(Operation::new(op))
            };

            use google_cloud_lro::internal::PollerExt;
            {
                google_cloud_lro::internal::new_poller(
                    polling_error_policy,
                    polling_backoff_policy,
                    start,
                    query,
                )
            }
            .with_options(poller_options)
        }

        /// Sets the value of [name][crate::model::UndeployProcessorVersionRequest::name].
        ///
        /// This is a **required** field for requests.
        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
            self.0.request.name = v.into();
            self
        }
    }

    #[doc(hidden)]
    impl crate::RequestBuilder for UndeployProcessorVersion {
        fn request_options(&mut self) -> &mut crate::RequestOptions {
            &mut self.0.options
        }
    }

    /// The request builder for [DocumentProcessorService::create_processor][crate::client::DocumentProcessorService::create_processor] calls.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_documentai_v1::builder::document_processor_service::CreateProcessor;
    /// # async fn sample() -> google_cloud_documentai_v1::Result<()> {
    ///
    /// let builder = prepare_request_builder();
    /// let response = builder.send().await?;
    /// # Ok(()) }
    ///
    /// fn prepare_request_builder() -> CreateProcessor {
    ///   # panic!();
    ///   // ... details omitted ...
    /// }
    /// ```
    #[derive(Clone, Debug)]
    pub struct CreateProcessor(RequestBuilder<crate::model::CreateProcessorRequest>);

    impl CreateProcessor {
        pub(crate) fn new(
            stub: std::sync::Arc<dyn super::super::stub::dynamic::DocumentProcessorService>,
        ) -> Self {
            Self(RequestBuilder::new(stub))
        }

        /// Sets the full request, replacing any prior values.
        pub fn with_request<V: Into<crate::model::CreateProcessorRequest>>(mut self, v: V) -> Self {
            self.0.request = v.into();
            self
        }

        /// Sets all the options, replacing any prior values.
        pub fn with_options<V: Into<crate::RequestOptions>>(mut self, v: V) -> Self {
            self.0.options = v.into();
            self
        }

        /// Sends the request.
        pub async fn send(self) -> Result<crate::model::Processor> {
            (*self.0.stub)
                .create_processor(self.0.request, self.0.options)
                .await
                .map(crate::Response::into_body)
        }

        /// Sets the value of [parent][crate::model::CreateProcessorRequest::parent].
        ///
        /// This is a **required** field for requests.
        pub fn set_parent<T: Into<std::string::String>>(mut self, v: T) -> Self {
            self.0.request.parent = v.into();
            self
        }

        /// Sets the value of [processor][crate::model::CreateProcessorRequest::processor].
        ///
        /// This is a **required** field for requests.
        pub fn set_processor<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<crate::model::Processor>,
        {
            self.0.request.processor = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [processor][crate::model::CreateProcessorRequest::processor].
        ///
        /// This is a **required** field for requests.
        pub fn set_or_clear_processor<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<crate::model::Processor>,
        {
            self.0.request.processor = v.map(|x| x.into());
            self
        }
    }

    #[doc(hidden)]
    impl crate::RequestBuilder for CreateProcessor {
        fn request_options(&mut self) -> &mut crate::RequestOptions {
            &mut self.0.options
        }
    }

    /// The request builder for [DocumentProcessorService::delete_processor][crate::client::DocumentProcessorService::delete_processor] calls.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_documentai_v1::builder::document_processor_service::DeleteProcessor;
    /// # async fn sample() -> google_cloud_documentai_v1::Result<()> {
    /// use google_cloud_lro::Poller;
    ///
    /// let builder = prepare_request_builder();
    /// let response = builder.poller().until_done().await?;
    /// # Ok(()) }
    ///
    /// fn prepare_request_builder() -> DeleteProcessor {
    ///   # panic!();
    ///   // ... details omitted ...
    /// }
    /// ```
    #[derive(Clone, Debug)]
    pub struct DeleteProcessor(RequestBuilder<crate::model::DeleteProcessorRequest>);

    impl DeleteProcessor {
        pub(crate) fn new(
            stub: std::sync::Arc<dyn super::super::stub::dynamic::DocumentProcessorService>,
        ) -> Self {
            Self(RequestBuilder::new(stub))
        }

        /// Sets the full request, replacing any prior values.
        pub fn with_request<V: Into<crate::model::DeleteProcessorRequest>>(mut self, v: V) -> Self {
            self.0.request = v.into();
            self
        }

        /// Sets all the options, replacing any prior values.
        pub fn with_options<V: Into<crate::RequestOptions>>(mut self, v: V) -> Self {
            self.0.options = v.into();
            self
        }

        /// Sends the request.
        ///
        /// # Long running operations
        ///
        /// This starts, but does not poll, a longrunning operation. More information
        /// on [delete_processor][crate::client::DocumentProcessorService::delete_processor].
        pub async fn send(self) -> Result<google_cloud_longrunning::model::Operation> {
            (*self.0.stub)
                .delete_processor(self.0.request, self.0.options)
                .await
                .map(crate::Response::into_body)
        }

        /// Creates a [Poller][google_cloud_lro::Poller] to work with `delete_processor`.
        pub fn poller(
            self,
        ) -> impl google_cloud_lro::Poller<(), crate::model::DeleteProcessorMetadata> {
            type Operation = google_cloud_lro::internal::Operation<
                wkt::Empty,
                crate::model::DeleteProcessorMetadata,
            >;
            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
            let mut poller_options = self.0.stub.get_poller_options(&self.0.options);
            if let Some(ref mut details) = poller_options.tracing {
                details.method_name = "google_cloud_documentai_v1::client::DocumentProcessorService::delete_processor::until_done";
            }

            let stub = self.0.stub.clone();
            let mut options = self.0.options.clone();
            options.set_retry_policy(google_cloud_gax::retry_policy::NeverRetry);
            let query = move |name| {
                let stub = stub.clone();
                let options = options.clone();
                async {
                    let op = GetOperation::new(stub)
                        .set_name(name)
                        .with_options(options)
                        .send()
                        .await?;
                    Ok(Operation::new(op))
                }
            };

            let start = move || async {
                let op = self.send().await?;
                Ok(Operation::new(op))
            };

            use google_cloud_lro::internal::PollerExt;
            {
                google_cloud_lro::internal::new_unit_response_poller(
                    polling_error_policy,
                    polling_backoff_policy,
                    start,
                    query,
                )
            }
            .with_options(poller_options)
        }

        /// Sets the value of [name][crate::model::DeleteProcessorRequest::name].
        ///
        /// This is a **required** field for requests.
        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
            self.0.request.name = v.into();
            self
        }
    }

    #[doc(hidden)]
    impl crate::RequestBuilder for DeleteProcessor {
        fn request_options(&mut self) -> &mut crate::RequestOptions {
            &mut self.0.options
        }
    }

    /// The request builder for [DocumentProcessorService::enable_processor][crate::client::DocumentProcessorService::enable_processor] calls.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_documentai_v1::builder::document_processor_service::EnableProcessor;
    /// # async fn sample() -> google_cloud_documentai_v1::Result<()> {
    /// use google_cloud_lro::Poller;
    ///
    /// let builder = prepare_request_builder();
    /// let response = builder.poller().until_done().await?;
    /// # Ok(()) }
    ///
    /// fn prepare_request_builder() -> EnableProcessor {
    ///   # panic!();
    ///   // ... details omitted ...
    /// }
    /// ```
    #[derive(Clone, Debug)]
    pub struct EnableProcessor(RequestBuilder<crate::model::EnableProcessorRequest>);

    impl EnableProcessor {
        pub(crate) fn new(
            stub: std::sync::Arc<dyn super::super::stub::dynamic::DocumentProcessorService>,
        ) -> Self {
            Self(RequestBuilder::new(stub))
        }

        /// Sets the full request, replacing any prior values.
        pub fn with_request<V: Into<crate::model::EnableProcessorRequest>>(mut self, v: V) -> Self {
            self.0.request = v.into();
            self
        }

        /// Sets all the options, replacing any prior values.
        pub fn with_options<V: Into<crate::RequestOptions>>(mut self, v: V) -> Self {
            self.0.options = v.into();
            self
        }

        /// Sends the request.
        ///
        /// # Long running operations
        ///
        /// This starts, but does not poll, a longrunning operation. More information
        /// on [enable_processor][crate::client::DocumentProcessorService::enable_processor].
        pub async fn send(self) -> Result<google_cloud_longrunning::model::Operation> {
            (*self.0.stub)
                .enable_processor(self.0.request, self.0.options)
                .await
                .map(crate::Response::into_body)
        }

        /// Creates a [Poller][google_cloud_lro::Poller] to work with `enable_processor`.
        pub fn poller(
            self,
        ) -> impl google_cloud_lro::Poller<
            crate::model::EnableProcessorResponse,
            crate::model::EnableProcessorMetadata,
        > {
            type Operation = google_cloud_lro::internal::Operation<
                crate::model::EnableProcessorResponse,
                crate::model::EnableProcessorMetadata,
            >;
            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
            let mut poller_options = self.0.stub.get_poller_options(&self.0.options);
            if let Some(ref mut details) = poller_options.tracing {
                details.method_name = "google_cloud_documentai_v1::client::DocumentProcessorService::enable_processor::until_done";
            }

            let stub = self.0.stub.clone();
            let mut options = self.0.options.clone();
            options.set_retry_policy(google_cloud_gax::retry_policy::NeverRetry);
            let query = move |name| {
                let stub = stub.clone();
                let options = options.clone();
                async {
                    let op = GetOperation::new(stub)
                        .set_name(name)
                        .with_options(options)
                        .send()
                        .await?;
                    Ok(Operation::new(op))
                }
            };

            let start = move || async {
                let op = self.send().await?;
                Ok(Operation::new(op))
            };

            use google_cloud_lro::internal::PollerExt;
            {
                google_cloud_lro::internal::new_poller(
                    polling_error_policy,
                    polling_backoff_policy,
                    start,
                    query,
                )
            }
            .with_options(poller_options)
        }

        /// Sets the value of [name][crate::model::EnableProcessorRequest::name].
        ///
        /// This is a **required** field for requests.
        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
            self.0.request.name = v.into();
            self
        }
    }

    #[doc(hidden)]
    impl crate::RequestBuilder for EnableProcessor {
        fn request_options(&mut self) -> &mut crate::RequestOptions {
            &mut self.0.options
        }
    }

    /// The request builder for [DocumentProcessorService::disable_processor][crate::client::DocumentProcessorService::disable_processor] calls.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_documentai_v1::builder::document_processor_service::DisableProcessor;
    /// # async fn sample() -> google_cloud_documentai_v1::Result<()> {
    /// use google_cloud_lro::Poller;
    ///
    /// let builder = prepare_request_builder();
    /// let response = builder.poller().until_done().await?;
    /// # Ok(()) }
    ///
    /// fn prepare_request_builder() -> DisableProcessor {
    ///   # panic!();
    ///   // ... details omitted ...
    /// }
    /// ```
    #[derive(Clone, Debug)]
    pub struct DisableProcessor(RequestBuilder<crate::model::DisableProcessorRequest>);

    impl DisableProcessor {
        pub(crate) fn new(
            stub: std::sync::Arc<dyn super::super::stub::dynamic::DocumentProcessorService>,
        ) -> Self {
            Self(RequestBuilder::new(stub))
        }

        /// Sets the full request, replacing any prior values.
        pub fn with_request<V: Into<crate::model::DisableProcessorRequest>>(
            mut self,
            v: V,
        ) -> Self {
            self.0.request = v.into();
            self
        }

        /// Sets all the options, replacing any prior values.
        pub fn with_options<V: Into<crate::RequestOptions>>(mut self, v: V) -> Self {
            self.0.options = v.into();
            self
        }

        /// Sends the request.
        ///
        /// # Long running operations
        ///
        /// This starts, but does not poll, a longrunning operation. More information
        /// on [disable_processor][crate::client::DocumentProcessorService::disable_processor].
        pub async fn send(self) -> Result<google_cloud_longrunning::model::Operation> {
            (*self.0.stub)
                .disable_processor(self.0.request, self.0.options)
                .await
                .map(crate::Response::into_body)
        }

        /// Creates a [Poller][google_cloud_lro::Poller] to work with `disable_processor`.
        pub fn poller(
            self,
        ) -> impl google_cloud_lro::Poller<
            crate::model::DisableProcessorResponse,
            crate::model::DisableProcessorMetadata,
        > {
            type Operation = google_cloud_lro::internal::Operation<
                crate::model::DisableProcessorResponse,
                crate::model::DisableProcessorMetadata,
            >;
            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
            let mut poller_options = self.0.stub.get_poller_options(&self.0.options);
            if let Some(ref mut details) = poller_options.tracing {
                details.method_name = "google_cloud_documentai_v1::client::DocumentProcessorService::disable_processor::until_done";
            }

            let stub = self.0.stub.clone();
            let mut options = self.0.options.clone();
            options.set_retry_policy(google_cloud_gax::retry_policy::NeverRetry);
            let query = move |name| {
                let stub = stub.clone();
                let options = options.clone();
                async {
                    let op = GetOperation::new(stub)
                        .set_name(name)
                        .with_options(options)
                        .send()
                        .await?;
                    Ok(Operation::new(op))
                }
            };

            let start = move || async {
                let op = self.send().await?;
                Ok(Operation::new(op))
            };

            use google_cloud_lro::internal::PollerExt;
            {
                google_cloud_lro::internal::new_poller(
                    polling_error_policy,
                    polling_backoff_policy,
                    start,
                    query,
                )
            }
            .with_options(poller_options)
        }

        /// Sets the value of [name][crate::model::DisableProcessorRequest::name].
        ///
        /// This is a **required** field for requests.
        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
            self.0.request.name = v.into();
            self
        }
    }

    #[doc(hidden)]
    impl crate::RequestBuilder for DisableProcessor {
        fn request_options(&mut self) -> &mut crate::RequestOptions {
            &mut self.0.options
        }
    }

    /// The request builder for [DocumentProcessorService::set_default_processor_version][crate::client::DocumentProcessorService::set_default_processor_version] calls.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_documentai_v1::builder::document_processor_service::SetDefaultProcessorVersion;
    /// # async fn sample() -> google_cloud_documentai_v1::Result<()> {
    /// use google_cloud_lro::Poller;
    ///
    /// let builder = prepare_request_builder();
    /// let response = builder.poller().until_done().await?;
    /// # Ok(()) }
    ///
    /// fn prepare_request_builder() -> SetDefaultProcessorVersion {
    ///   # panic!();
    ///   // ... details omitted ...
    /// }
    /// ```
    #[derive(Clone, Debug)]
    pub struct SetDefaultProcessorVersion(
        RequestBuilder<crate::model::SetDefaultProcessorVersionRequest>,
    );

    impl SetDefaultProcessorVersion {
        pub(crate) fn new(
            stub: std::sync::Arc<dyn super::super::stub::dynamic::DocumentProcessorService>,
        ) -> Self {
            Self(RequestBuilder::new(stub))
        }

        /// Sets the full request, replacing any prior values.
        pub fn with_request<V: Into<crate::model::SetDefaultProcessorVersionRequest>>(
            mut self,
            v: V,
        ) -> Self {
            self.0.request = v.into();
            self
        }

        /// Sets all the options, replacing any prior values.
        pub fn with_options<V: Into<crate::RequestOptions>>(mut self, v: V) -> Self {
            self.0.options = v.into();
            self
        }

        /// Sends the request.
        ///
        /// # Long running operations
        ///
        /// This starts, but does not poll, a longrunning operation. More information
        /// on [set_default_processor_version][crate::client::DocumentProcessorService::set_default_processor_version].
        pub async fn send(self) -> Result<google_cloud_longrunning::model::Operation> {
            (*self.0.stub)
                .set_default_processor_version(self.0.request, self.0.options)
                .await
                .map(crate::Response::into_body)
        }

        /// Creates a [Poller][google_cloud_lro::Poller] to work with `set_default_processor_version`.
        pub fn poller(
            self,
        ) -> impl google_cloud_lro::Poller<
            crate::model::SetDefaultProcessorVersionResponse,
            crate::model::SetDefaultProcessorVersionMetadata,
        > {
            type Operation = google_cloud_lro::internal::Operation<
                crate::model::SetDefaultProcessorVersionResponse,
                crate::model::SetDefaultProcessorVersionMetadata,
            >;
            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
            let mut poller_options = self.0.stub.get_poller_options(&self.0.options);
            if let Some(ref mut details) = poller_options.tracing {
                details.method_name = "google_cloud_documentai_v1::client::DocumentProcessorService::set_default_processor_version::until_done";
            }

            let stub = self.0.stub.clone();
            let mut options = self.0.options.clone();
            options.set_retry_policy(google_cloud_gax::retry_policy::NeverRetry);
            let query = move |name| {
                let stub = stub.clone();
                let options = options.clone();
                async {
                    let op = GetOperation::new(stub)
                        .set_name(name)
                        .with_options(options)
                        .send()
                        .await?;
                    Ok(Operation::new(op))
                }
            };

            let start = move || async {
                let op = self.send().await?;
                Ok(Operation::new(op))
            };

            use google_cloud_lro::internal::PollerExt;
            {
                google_cloud_lro::internal::new_poller(
                    polling_error_policy,
                    polling_backoff_policy,
                    start,
                    query,
                )
            }
            .with_options(poller_options)
        }

        /// Sets the value of [processor][crate::model::SetDefaultProcessorVersionRequest::processor].
        ///
        /// This is a **required** field for requests.
        pub fn set_processor<T: Into<std::string::String>>(mut self, v: T) -> Self {
            self.0.request.processor = v.into();
            self
        }

        /// Sets the value of [default_processor_version][crate::model::SetDefaultProcessorVersionRequest::default_processor_version].
        ///
        /// This is a **required** field for requests.
        pub fn set_default_processor_version<T: Into<std::string::String>>(mut self, v: T) -> Self {
            self.0.request.default_processor_version = v.into();
            self
        }
    }

    #[doc(hidden)]
    impl crate::RequestBuilder for SetDefaultProcessorVersion {
        fn request_options(&mut self) -> &mut crate::RequestOptions {
            &mut self.0.options
        }
    }

    /// The request builder for [DocumentProcessorService::review_document][crate::client::DocumentProcessorService::review_document] calls.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_documentai_v1::builder::document_processor_service::ReviewDocument;
    /// # async fn sample() -> google_cloud_documentai_v1::Result<()> {
    /// use google_cloud_lro::Poller;
    ///
    /// let builder = prepare_request_builder();
    /// let response = builder.poller().until_done().await?;
    /// # Ok(()) }
    ///
    /// fn prepare_request_builder() -> ReviewDocument {
    ///   # panic!();
    ///   // ... details omitted ...
    /// }
    /// ```
    #[derive(Clone, Debug)]
    pub struct ReviewDocument(RequestBuilder<crate::model::ReviewDocumentRequest>);

    impl ReviewDocument {
        pub(crate) fn new(
            stub: std::sync::Arc<dyn super::super::stub::dynamic::DocumentProcessorService>,
        ) -> Self {
            Self(RequestBuilder::new(stub))
        }

        /// Sets the full request, replacing any prior values.
        pub fn with_request<V: Into<crate::model::ReviewDocumentRequest>>(mut self, v: V) -> Self {
            self.0.request = v.into();
            self
        }

        /// Sets all the options, replacing any prior values.
        pub fn with_options<V: Into<crate::RequestOptions>>(mut self, v: V) -> Self {
            self.0.options = v.into();
            self
        }

        /// Sends the request.
        ///
        /// # Long running operations
        ///
        /// This starts, but does not poll, a longrunning operation. More information
        /// on [review_document][crate::client::DocumentProcessorService::review_document].
        pub async fn send(self) -> Result<google_cloud_longrunning::model::Operation> {
            (*self.0.stub)
                .review_document(self.0.request, self.0.options)
                .await
                .map(crate::Response::into_body)
        }

        /// Creates a [Poller][google_cloud_lro::Poller] to work with `review_document`.
        pub fn poller(
            self,
        ) -> impl google_cloud_lro::Poller<
            crate::model::ReviewDocumentResponse,
            crate::model::ReviewDocumentOperationMetadata,
        > {
            type Operation = google_cloud_lro::internal::Operation<
                crate::model::ReviewDocumentResponse,
                crate::model::ReviewDocumentOperationMetadata,
            >;
            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
            let mut poller_options = self.0.stub.get_poller_options(&self.0.options);
            if let Some(ref mut details) = poller_options.tracing {
                details.method_name = "google_cloud_documentai_v1::client::DocumentProcessorService::review_document::until_done";
            }

            let stub = self.0.stub.clone();
            let mut options = self.0.options.clone();
            options.set_retry_policy(google_cloud_gax::retry_policy::NeverRetry);
            let query = move |name| {
                let stub = stub.clone();
                let options = options.clone();
                async {
                    let op = GetOperation::new(stub)
                        .set_name(name)
                        .with_options(options)
                        .send()
                        .await?;
                    Ok(Operation::new(op))
                }
            };

            let start = move || async {
                let op = self.send().await?;
                Ok(Operation::new(op))
            };

            use google_cloud_lro::internal::PollerExt;
            {
                google_cloud_lro::internal::new_poller(
                    polling_error_policy,
                    polling_backoff_policy,
                    start,
                    query,
                )
            }
            .with_options(poller_options)
        }

        /// Sets the value of [human_review_config][crate::model::ReviewDocumentRequest::human_review_config].
        ///
        /// This is a **required** field for requests.
        pub fn set_human_review_config<T: Into<std::string::String>>(mut self, v: T) -> Self {
            self.0.request.human_review_config = v.into();
            self
        }

        /// Sets the value of [enable_schema_validation][crate::model::ReviewDocumentRequest::enable_schema_validation].
        pub fn set_enable_schema_validation<T: Into<bool>>(mut self, v: T) -> Self {
            self.0.request.enable_schema_validation = v.into();
            self
        }

        /// Sets the value of [priority][crate::model::ReviewDocumentRequest::priority].
        pub fn set_priority<T: Into<crate::model::review_document_request::Priority>>(
            mut self,
            v: T,
        ) -> Self {
            self.0.request.priority = v.into();
            self
        }

        /// Sets the value of [document_schema][crate::model::ReviewDocumentRequest::document_schema].
        pub fn set_document_schema<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<crate::model::DocumentSchema>,
        {
            self.0.request.document_schema = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [document_schema][crate::model::ReviewDocumentRequest::document_schema].
        pub fn set_or_clear_document_schema<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<crate::model::DocumentSchema>,
        {
            self.0.request.document_schema = v.map(|x| x.into());
            self
        }

        /// Sets the value of [source][crate::model::ReviewDocumentRequest::source].
        ///
        /// Note that all the setters affecting `source` are
        /// mutually exclusive.
        pub fn set_source<T: Into<Option<crate::model::review_document_request::Source>>>(
            mut self,
            v: T,
        ) -> Self {
            self.0.request.source = v.into();
            self
        }

        /// Sets the value of [source][crate::model::ReviewDocumentRequest::source]
        /// to hold a `InlineDocument`.
        ///
        /// Note that all the setters affecting `source` are
        /// mutually exclusive.
        pub fn set_inline_document<
            T: std::convert::Into<std::boxed::Box<crate::model::Document>>,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.0.request = self.0.request.set_inline_document(v);
            self
        }
    }

    #[doc(hidden)]
    impl crate::RequestBuilder for ReviewDocument {
        fn request_options(&mut self) -> &mut crate::RequestOptions {
            &mut self.0.options
        }
    }

    /// The request builder for [DocumentProcessorService::evaluate_processor_version][crate::client::DocumentProcessorService::evaluate_processor_version] calls.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_documentai_v1::builder::document_processor_service::EvaluateProcessorVersion;
    /// # async fn sample() -> google_cloud_documentai_v1::Result<()> {
    /// use google_cloud_lro::Poller;
    ///
    /// let builder = prepare_request_builder();
    /// let response = builder.poller().until_done().await?;
    /// # Ok(()) }
    ///
    /// fn prepare_request_builder() -> EvaluateProcessorVersion {
    ///   # panic!();
    ///   // ... details omitted ...
    /// }
    /// ```
    #[derive(Clone, Debug)]
    pub struct EvaluateProcessorVersion(
        RequestBuilder<crate::model::EvaluateProcessorVersionRequest>,
    );

    impl EvaluateProcessorVersion {
        pub(crate) fn new(
            stub: std::sync::Arc<dyn super::super::stub::dynamic::DocumentProcessorService>,
        ) -> Self {
            Self(RequestBuilder::new(stub))
        }

        /// Sets the full request, replacing any prior values.
        pub fn with_request<V: Into<crate::model::EvaluateProcessorVersionRequest>>(
            mut self,
            v: V,
        ) -> Self {
            self.0.request = v.into();
            self
        }

        /// Sets all the options, replacing any prior values.
        pub fn with_options<V: Into<crate::RequestOptions>>(mut self, v: V) -> Self {
            self.0.options = v.into();
            self
        }

        /// Sends the request.
        ///
        /// # Long running operations
        ///
        /// This starts, but does not poll, a longrunning operation. More information
        /// on [evaluate_processor_version][crate::client::DocumentProcessorService::evaluate_processor_version].
        pub async fn send(self) -> Result<google_cloud_longrunning::model::Operation> {
            (*self.0.stub)
                .evaluate_processor_version(self.0.request, self.0.options)
                .await
                .map(crate::Response::into_body)
        }

        /// Creates a [Poller][google_cloud_lro::Poller] to work with `evaluate_processor_version`.
        pub fn poller(
            self,
        ) -> impl google_cloud_lro::Poller<
            crate::model::EvaluateProcessorVersionResponse,
            crate::model::EvaluateProcessorVersionMetadata,
        > {
            type Operation = google_cloud_lro::internal::Operation<
                crate::model::EvaluateProcessorVersionResponse,
                crate::model::EvaluateProcessorVersionMetadata,
            >;
            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
            let mut poller_options = self.0.stub.get_poller_options(&self.0.options);
            if let Some(ref mut details) = poller_options.tracing {
                details.method_name = "google_cloud_documentai_v1::client::DocumentProcessorService::evaluate_processor_version::until_done";
            }

            let stub = self.0.stub.clone();
            let mut options = self.0.options.clone();
            options.set_retry_policy(google_cloud_gax::retry_policy::NeverRetry);
            let query = move |name| {
                let stub = stub.clone();
                let options = options.clone();
                async {
                    let op = GetOperation::new(stub)
                        .set_name(name)
                        .with_options(options)
                        .send()
                        .await?;
                    Ok(Operation::new(op))
                }
            };

            let start = move || async {
                let op = self.send().await?;
                Ok(Operation::new(op))
            };

            use google_cloud_lro::internal::PollerExt;
            {
                google_cloud_lro::internal::new_poller(
                    polling_error_policy,
                    polling_backoff_policy,
                    start,
                    query,
                )
            }
            .with_options(poller_options)
        }

        /// Sets the value of [processor_version][crate::model::EvaluateProcessorVersionRequest::processor_version].
        ///
        /// This is a **required** field for requests.
        pub fn set_processor_version<T: Into<std::string::String>>(mut self, v: T) -> Self {
            self.0.request.processor_version = v.into();
            self
        }

        /// Sets the value of [evaluation_documents][crate::model::EvaluateProcessorVersionRequest::evaluation_documents].
        pub fn set_evaluation_documents<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<crate::model::BatchDocumentsInputConfig>,
        {
            self.0.request.evaluation_documents = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [evaluation_documents][crate::model::EvaluateProcessorVersionRequest::evaluation_documents].
        pub fn set_or_clear_evaluation_documents<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<crate::model::BatchDocumentsInputConfig>,
        {
            self.0.request.evaluation_documents = v.map(|x| x.into());
            self
        }
    }

    #[doc(hidden)]
    impl crate::RequestBuilder for EvaluateProcessorVersion {
        fn request_options(&mut self) -> &mut crate::RequestOptions {
            &mut self.0.options
        }
    }

    /// The request builder for [DocumentProcessorService::get_evaluation][crate::client::DocumentProcessorService::get_evaluation] calls.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_documentai_v1::builder::document_processor_service::GetEvaluation;
    /// # async fn sample() -> google_cloud_documentai_v1::Result<()> {
    ///
    /// let builder = prepare_request_builder();
    /// let response = builder.send().await?;
    /// # Ok(()) }
    ///
    /// fn prepare_request_builder() -> GetEvaluation {
    ///   # panic!();
    ///   // ... details omitted ...
    /// }
    /// ```
    #[derive(Clone, Debug)]
    pub struct GetEvaluation(RequestBuilder<crate::model::GetEvaluationRequest>);

    impl GetEvaluation {
        pub(crate) fn new(
            stub: std::sync::Arc<dyn super::super::stub::dynamic::DocumentProcessorService>,
        ) -> Self {
            Self(RequestBuilder::new(stub))
        }

        /// Sets the full request, replacing any prior values.
        pub fn with_request<V: Into<crate::model::GetEvaluationRequest>>(mut self, v: V) -> Self {
            self.0.request = v.into();
            self
        }

        /// Sets all the options, replacing any prior values.
        pub fn with_options<V: Into<crate::RequestOptions>>(mut self, v: V) -> Self {
            self.0.options = v.into();
            self
        }

        /// Sends the request.
        pub async fn send(self) -> Result<crate::model::Evaluation> {
            (*self.0.stub)
                .get_evaluation(self.0.request, self.0.options)
                .await
                .map(crate::Response::into_body)
        }

        /// Sets the value of [name][crate::model::GetEvaluationRequest::name].
        ///
        /// This is a **required** field for requests.
        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
            self.0.request.name = v.into();
            self
        }
    }

    #[doc(hidden)]
    impl crate::RequestBuilder for GetEvaluation {
        fn request_options(&mut self) -> &mut crate::RequestOptions {
            &mut self.0.options
        }
    }

    /// The request builder for [DocumentProcessorService::list_evaluations][crate::client::DocumentProcessorService::list_evaluations] calls.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_documentai_v1::builder::document_processor_service::ListEvaluations;
    /// # async fn sample() -> google_cloud_documentai_v1::Result<()> {
    /// use google_cloud_gax::paginator::ItemPaginator;
    ///
    /// let builder = prepare_request_builder();
    /// let mut items = builder.by_item();
    /// while let Some(result) = items.next().await {
    ///   let item = result?;
    /// }
    /// # Ok(()) }
    ///
    /// fn prepare_request_builder() -> ListEvaluations {
    ///   # panic!();
    ///   // ... details omitted ...
    /// }
    /// ```
    #[derive(Clone, Debug)]
    pub struct ListEvaluations(RequestBuilder<crate::model::ListEvaluationsRequest>);

    impl ListEvaluations {
        pub(crate) fn new(
            stub: std::sync::Arc<dyn super::super::stub::dynamic::DocumentProcessorService>,
        ) -> Self {
            Self(RequestBuilder::new(stub))
        }

        /// Sets the full request, replacing any prior values.
        pub fn with_request<V: Into<crate::model::ListEvaluationsRequest>>(mut self, v: V) -> Self {
            self.0.request = v.into();
            self
        }

        /// Sets all the options, replacing any prior values.
        pub fn with_options<V: Into<crate::RequestOptions>>(mut self, v: V) -> Self {
            self.0.options = v.into();
            self
        }

        /// Sends the request.
        pub async fn send(self) -> Result<crate::model::ListEvaluationsResponse> {
            (*self.0.stub)
                .list_evaluations(self.0.request, self.0.options)
                .await
                .map(crate::Response::into_body)
        }

        /// Streams each page in the collection.
        pub fn by_page(
            self,
        ) -> impl google_cloud_gax::paginator::Paginator<
            crate::model::ListEvaluationsResponse,
            crate::Error,
        > {
            use std::clone::Clone;
            let token = self.0.request.page_token.clone();
            let execute = move |token: String| {
                let mut builder = self.clone();
                builder.0.request = builder.0.request.set_page_token(token);
                builder.send()
            };
            google_cloud_gax::paginator::internal::new_paginator(token, execute)
        }

        /// Streams each item in the collection.
        pub fn by_item(
            self,
        ) -> impl google_cloud_gax::paginator::ItemPaginator<
            crate::model::ListEvaluationsResponse,
            crate::Error,
        > {
            use google_cloud_gax::paginator::Paginator;
            self.by_page().items()
        }

        /// Sets the value of [parent][crate::model::ListEvaluationsRequest::parent].
        ///
        /// This is a **required** field for requests.
        pub fn set_parent<T: Into<std::string::String>>(mut self, v: T) -> Self {
            self.0.request.parent = v.into();
            self
        }

        /// Sets the value of [page_size][crate::model::ListEvaluationsRequest::page_size].
        pub fn set_page_size<T: Into<i32>>(mut self, v: T) -> Self {
            self.0.request.page_size = v.into();
            self
        }

        /// Sets the value of [page_token][crate::model::ListEvaluationsRequest::page_token].
        pub fn set_page_token<T: Into<std::string::String>>(mut self, v: T) -> Self {
            self.0.request.page_token = v.into();
            self
        }
    }

    #[doc(hidden)]
    impl crate::RequestBuilder for ListEvaluations {
        fn request_options(&mut self) -> &mut crate::RequestOptions {
            &mut self.0.options
        }
    }

    /// The request builder for [DocumentProcessorService::list_locations][crate::client::DocumentProcessorService::list_locations] calls.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_documentai_v1::builder::document_processor_service::ListLocations;
    /// # async fn sample() -> google_cloud_documentai_v1::Result<()> {
    /// use google_cloud_gax::paginator::ItemPaginator;
    ///
    /// let builder = prepare_request_builder();
    /// let mut items = builder.by_item();
    /// while let Some(result) = items.next().await {
    ///   let item = result?;
    /// }
    /// # Ok(()) }
    ///
    /// fn prepare_request_builder() -> ListLocations {
    ///   # panic!();
    ///   // ... details omitted ...
    /// }
    /// ```
    #[derive(Clone, Debug)]
    pub struct ListLocations(RequestBuilder<google_cloud_location::model::ListLocationsRequest>);

    impl ListLocations {
        pub(crate) fn new(
            stub: std::sync::Arc<dyn super::super::stub::dynamic::DocumentProcessorService>,
        ) -> Self {
            Self(RequestBuilder::new(stub))
        }

        /// Sets the full request, replacing any prior values.
        pub fn with_request<V: Into<google_cloud_location::model::ListLocationsRequest>>(
            mut self,
            v: V,
        ) -> Self {
            self.0.request = v.into();
            self
        }

        /// Sets all the options, replacing any prior values.
        pub fn with_options<V: Into<crate::RequestOptions>>(mut self, v: V) -> Self {
            self.0.options = v.into();
            self
        }

        /// Sends the request.
        pub async fn send(self) -> Result<google_cloud_location::model::ListLocationsResponse> {
            (*self.0.stub)
                .list_locations(self.0.request, self.0.options)
                .await
                .map(crate::Response::into_body)
        }

        /// Streams each page in the collection.
        pub fn by_page(
            self,
        ) -> impl google_cloud_gax::paginator::Paginator<
            google_cloud_location::model::ListLocationsResponse,
            crate::Error,
        > {
            use std::clone::Clone;
            let token = self.0.request.page_token.clone();
            let execute = move |token: String| {
                let mut builder = self.clone();
                builder.0.request = builder.0.request.set_page_token(token);
                builder.send()
            };
            google_cloud_gax::paginator::internal::new_paginator(token, execute)
        }

        /// Streams each item in the collection.
        pub fn by_item(
            self,
        ) -> impl google_cloud_gax::paginator::ItemPaginator<
            google_cloud_location::model::ListLocationsResponse,
            crate::Error,
        > {
            use google_cloud_gax::paginator::Paginator;
            self.by_page().items()
        }

        /// Sets the value of [name][google_cloud_location::model::ListLocationsRequest::name].
        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
            self.0.request.name = v.into();
            self
        }

        /// Sets the value of [filter][google_cloud_location::model::ListLocationsRequest::filter].
        pub fn set_filter<T: Into<std::string::String>>(mut self, v: T) -> Self {
            self.0.request.filter = v.into();
            self
        }

        /// Sets the value of [page_size][google_cloud_location::model::ListLocationsRequest::page_size].
        pub fn set_page_size<T: Into<i32>>(mut self, v: T) -> Self {
            self.0.request.page_size = v.into();
            self
        }

        /// Sets the value of [page_token][google_cloud_location::model::ListLocationsRequest::page_token].
        pub fn set_page_token<T: Into<std::string::String>>(mut self, v: T) -> Self {
            self.0.request.page_token = v.into();
            self
        }
    }

    #[doc(hidden)]
    impl crate::RequestBuilder for ListLocations {
        fn request_options(&mut self) -> &mut crate::RequestOptions {
            &mut self.0.options
        }
    }

    /// The request builder for [DocumentProcessorService::get_location][crate::client::DocumentProcessorService::get_location] calls.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_documentai_v1::builder::document_processor_service::GetLocation;
    /// # async fn sample() -> google_cloud_documentai_v1::Result<()> {
    ///
    /// let builder = prepare_request_builder();
    /// let response = builder.send().await?;
    /// # Ok(()) }
    ///
    /// fn prepare_request_builder() -> GetLocation {
    ///   # panic!();
    ///   // ... details omitted ...
    /// }
    /// ```
    #[derive(Clone, Debug)]
    pub struct GetLocation(RequestBuilder<google_cloud_location::model::GetLocationRequest>);

    impl GetLocation {
        pub(crate) fn new(
            stub: std::sync::Arc<dyn super::super::stub::dynamic::DocumentProcessorService>,
        ) -> Self {
            Self(RequestBuilder::new(stub))
        }

        /// Sets the full request, replacing any prior values.
        pub fn with_request<V: Into<google_cloud_location::model::GetLocationRequest>>(
            mut self,
            v: V,
        ) -> Self {
            self.0.request = v.into();
            self
        }

        /// Sets all the options, replacing any prior values.
        pub fn with_options<V: Into<crate::RequestOptions>>(mut self, v: V) -> Self {
            self.0.options = v.into();
            self
        }

        /// Sends the request.
        pub async fn send(self) -> Result<google_cloud_location::model::Location> {
            (*self.0.stub)
                .get_location(self.0.request, self.0.options)
                .await
                .map(crate::Response::into_body)
        }

        /// Sets the value of [name][google_cloud_location::model::GetLocationRequest::name].
        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
            self.0.request.name = v.into();
            self
        }
    }

    #[doc(hidden)]
    impl crate::RequestBuilder for GetLocation {
        fn request_options(&mut self) -> &mut crate::RequestOptions {
            &mut self.0.options
        }
    }

    /// The request builder for [DocumentProcessorService::list_operations][crate::client::DocumentProcessorService::list_operations] calls.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_documentai_v1::builder::document_processor_service::ListOperations;
    /// # async fn sample() -> google_cloud_documentai_v1::Result<()> {
    /// use google_cloud_gax::paginator::ItemPaginator;
    ///
    /// let builder = prepare_request_builder();
    /// let mut items = builder.by_item();
    /// while let Some(result) = items.next().await {
    ///   let item = result?;
    /// }
    /// # Ok(()) }
    ///
    /// fn prepare_request_builder() -> ListOperations {
    ///   # panic!();
    ///   // ... details omitted ...
    /// }
    /// ```
    #[derive(Clone, Debug)]
    pub struct ListOperations(
        RequestBuilder<google_cloud_longrunning::model::ListOperationsRequest>,
    );

    impl ListOperations {
        pub(crate) fn new(
            stub: std::sync::Arc<dyn super::super::stub::dynamic::DocumentProcessorService>,
        ) -> Self {
            Self(RequestBuilder::new(stub))
        }

        /// Sets the full request, replacing any prior values.
        pub fn with_request<V: Into<google_cloud_longrunning::model::ListOperationsRequest>>(
            mut self,
            v: V,
        ) -> Self {
            self.0.request = v.into();
            self
        }

        /// Sets all the options, replacing any prior values.
        pub fn with_options<V: Into<crate::RequestOptions>>(mut self, v: V) -> Self {
            self.0.options = v.into();
            self
        }

        /// Sends the request.
        pub async fn send(self) -> Result<google_cloud_longrunning::model::ListOperationsResponse> {
            (*self.0.stub)
                .list_operations(self.0.request, self.0.options)
                .await
                .map(crate::Response::into_body)
        }

        /// Streams each page in the collection.
        pub fn by_page(
            self,
        ) -> impl google_cloud_gax::paginator::Paginator<
            google_cloud_longrunning::model::ListOperationsResponse,
            crate::Error,
        > {
            use std::clone::Clone;
            let token = self.0.request.page_token.clone();
            let execute = move |token: String| {
                let mut builder = self.clone();
                builder.0.request = builder.0.request.set_page_token(token);
                builder.send()
            };
            google_cloud_gax::paginator::internal::new_paginator(token, execute)
        }

        /// Streams each item in the collection.
        pub fn by_item(
            self,
        ) -> impl google_cloud_gax::paginator::ItemPaginator<
            google_cloud_longrunning::model::ListOperationsResponse,
            crate::Error,
        > {
            use google_cloud_gax::paginator::Paginator;
            self.by_page().items()
        }

        /// Sets the value of [name][google_cloud_longrunning::model::ListOperationsRequest::name].
        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
            self.0.request.name = v.into();
            self
        }

        /// Sets the value of [filter][google_cloud_longrunning::model::ListOperationsRequest::filter].
        pub fn set_filter<T: Into<std::string::String>>(mut self, v: T) -> Self {
            self.0.request.filter = v.into();
            self
        }

        /// Sets the value of [page_size][google_cloud_longrunning::model::ListOperationsRequest::page_size].
        pub fn set_page_size<T: Into<i32>>(mut self, v: T) -> Self {
            self.0.request.page_size = v.into();
            self
        }

        /// Sets the value of [page_token][google_cloud_longrunning::model::ListOperationsRequest::page_token].
        pub fn set_page_token<T: Into<std::string::String>>(mut self, v: T) -> Self {
            self.0.request.page_token = v.into();
            self
        }

        /// Sets the value of [return_partial_success][google_cloud_longrunning::model::ListOperationsRequest::return_partial_success].
        pub fn set_return_partial_success<T: Into<bool>>(mut self, v: T) -> Self {
            self.0.request.return_partial_success = v.into();
            self
        }
    }

    #[doc(hidden)]
    impl crate::RequestBuilder for ListOperations {
        fn request_options(&mut self) -> &mut crate::RequestOptions {
            &mut self.0.options
        }
    }

    /// The request builder for [DocumentProcessorService::get_operation][crate::client::DocumentProcessorService::get_operation] calls.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_documentai_v1::builder::document_processor_service::GetOperation;
    /// # async fn sample() -> google_cloud_documentai_v1::Result<()> {
    ///
    /// let builder = prepare_request_builder();
    /// let response = builder.send().await?;
    /// # Ok(()) }
    ///
    /// fn prepare_request_builder() -> GetOperation {
    ///   # panic!();
    ///   // ... details omitted ...
    /// }
    /// ```
    #[derive(Clone, Debug)]
    pub struct GetOperation(RequestBuilder<google_cloud_longrunning::model::GetOperationRequest>);

    impl GetOperation {
        pub(crate) fn new(
            stub: std::sync::Arc<dyn super::super::stub::dynamic::DocumentProcessorService>,
        ) -> Self {
            Self(RequestBuilder::new(stub))
        }

        /// Sets the full request, replacing any prior values.
        pub fn with_request<V: Into<google_cloud_longrunning::model::GetOperationRequest>>(
            mut self,
            v: V,
        ) -> Self {
            self.0.request = v.into();
            self
        }

        /// Sets all the options, replacing any prior values.
        pub fn with_options<V: Into<crate::RequestOptions>>(mut self, v: V) -> Self {
            self.0.options = v.into();
            self
        }

        /// Sends the request.
        pub async fn send(self) -> Result<google_cloud_longrunning::model::Operation> {
            (*self.0.stub)
                .get_operation(self.0.request, self.0.options)
                .await
                .map(crate::Response::into_body)
        }

        /// Sets the value of [name][google_cloud_longrunning::model::GetOperationRequest::name].
        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
            self.0.request.name = v.into();
            self
        }
    }

    #[doc(hidden)]
    impl crate::RequestBuilder for GetOperation {
        fn request_options(&mut self) -> &mut crate::RequestOptions {
            &mut self.0.options
        }
    }

    /// The request builder for [DocumentProcessorService::cancel_operation][crate::client::DocumentProcessorService::cancel_operation] calls.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_documentai_v1::builder::document_processor_service::CancelOperation;
    /// # async fn sample() -> google_cloud_documentai_v1::Result<()> {
    ///
    /// let builder = prepare_request_builder();
    /// let response = builder.send().await?;
    /// # Ok(()) }
    ///
    /// fn prepare_request_builder() -> CancelOperation {
    ///   # panic!();
    ///   // ... details omitted ...
    /// }
    /// ```
    #[derive(Clone, Debug)]
    pub struct CancelOperation(
        RequestBuilder<google_cloud_longrunning::model::CancelOperationRequest>,
    );

    impl CancelOperation {
        pub(crate) fn new(
            stub: std::sync::Arc<dyn super::super::stub::dynamic::DocumentProcessorService>,
        ) -> Self {
            Self(RequestBuilder::new(stub))
        }

        /// Sets the full request, replacing any prior values.
        pub fn with_request<V: Into<google_cloud_longrunning::model::CancelOperationRequest>>(
            mut self,
            v: V,
        ) -> Self {
            self.0.request = v.into();
            self
        }

        /// Sets all the options, replacing any prior values.
        pub fn with_options<V: Into<crate::RequestOptions>>(mut self, v: V) -> Self {
            self.0.options = v.into();
            self
        }

        /// Sends the request.
        pub async fn send(self) -> Result<()> {
            (*self.0.stub)
                .cancel_operation(self.0.request, self.0.options)
                .await
                .map(crate::Response::into_body)
        }

        /// Sets the value of [name][google_cloud_longrunning::model::CancelOperationRequest::name].
        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
            self.0.request.name = v.into();
            self
        }
    }

    #[doc(hidden)]
    impl crate::RequestBuilder for CancelOperation {
        fn request_options(&mut self) -> &mut crate::RequestOptions {
            &mut self.0.options
        }
    }
}