google-cloud-discoveryengine-v1 2.17.0

// 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.

use super::prost::google::cloud::discoveryengine::v1::*;

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::ToProto<HarmCategory> for crate::model::HarmCategory {
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value()
            .ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue(
                "crate::model::HarmCategory",
            ))
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::ToProto<answer::Citation> for crate::model::answer::Citation {
    type Output = answer::Citation;
    fn to_proto(self) -> std::result::Result<answer::Citation, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            start_index: self.start_index.to_proto()?,
            end_index: self.end_index.to_proto()?,
            sources: self
                .sources
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
        })
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::FromProto<crate::model::answer::Citation> for answer::Citation {
    fn cnv(self) -> std::result::Result<crate::model::answer::Citation, gaxi::prost::ConvertError> {
        Ok(crate::model::answer::Citation::new()
            .set_start_index(self.start_index)
            .set_end_index(self.end_index)
            .set_sources(
                self.sources
                    .into_iter()
                    .map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            ))
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::ToProto<answer::CitationSource> for crate::model::answer::CitationSource {
    type Output = answer::CitationSource;
    fn to_proto(self) -> std::result::Result<answer::CitationSource, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            reference_id: self.reference_id.to_proto()?,
        })
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::FromProto<crate::model::answer::CitationSource> for answer::CitationSource {
    fn cnv(
        self,
    ) -> std::result::Result<crate::model::answer::CitationSource, gaxi::prost::ConvertError> {
        Ok(crate::model::answer::CitationSource::new().set_reference_id(self.reference_id))
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::ToProto<answer::GroundingSupport> for crate::model::answer::GroundingSupport {
    type Output = answer::GroundingSupport;
    fn to_proto(self) -> std::result::Result<answer::GroundingSupport, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            start_index: self.start_index.to_proto()?,
            end_index: self.end_index.to_proto()?,
            grounding_score: self.grounding_score.map(|v| v.to_proto()).transpose()?,
            grounding_check_required: self
                .grounding_check_required
                .map(|v| v.to_proto())
                .transpose()?,
            sources: self
                .sources
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
        })
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::FromProto<crate::model::answer::GroundingSupport> for answer::GroundingSupport {
    fn cnv(
        self,
    ) -> std::result::Result<crate::model::answer::GroundingSupport, gaxi::prost::ConvertError>
    {
        Ok(crate::model::answer::GroundingSupport::new()
            .set_start_index(self.start_index)
            .set_end_index(self.end_index)
            .set_or_clear_grounding_score(self.grounding_score.map(|v| v.cnv()).transpose()?)
            .set_or_clear_grounding_check_required(
                self.grounding_check_required.map(|v| v.cnv()).transpose()?,
            )
            .set_sources(
                self.sources
                    .into_iter()
                    .map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            ))
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::ToProto<answer::reference::unstructured_document_info::ChunkContent>
    for crate::model::answer::reference::unstructured_document_info::ChunkContent
{
    type Output = answer::reference::unstructured_document_info::ChunkContent;
    fn to_proto(
        self,
    ) -> std::result::Result<
        answer::reference::unstructured_document_info::ChunkContent,
        gaxi::prost::ConvertError,
    > {
        Ok(Self::Output {
            content: self.content.to_proto()?,
            page_identifier: self.page_identifier.to_proto()?,
            relevance_score: self.relevance_score.map(|v| v.to_proto()).transpose()?,
        })
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl
    gaxi::prost::FromProto<
        crate::model::answer::reference::unstructured_document_info::ChunkContent,
    > for answer::reference::unstructured_document_info::ChunkContent
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::answer::reference::unstructured_document_info::ChunkContent,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::answer::reference::unstructured_document_info::ChunkContent::new()
                .set_content(self.content)
                .set_page_identifier(self.page_identifier)
                .set_or_clear_relevance_score(self.relevance_score.map(|v| v.cnv()).transpose()?),
        )
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::ToProto<answer::reference::UnstructuredDocumentInfo>
    for crate::model::answer::reference::UnstructuredDocumentInfo
{
    type Output = answer::reference::UnstructuredDocumentInfo;
    fn to_proto(
        self,
    ) -> std::result::Result<answer::reference::UnstructuredDocumentInfo, gaxi::prost::ConvertError>
    {
        Ok(Self::Output {
            document: self.document.to_proto()?,
            uri: self.uri.to_proto()?,
            title: self.title.to_proto()?,
            chunk_contents: self
                .chunk_contents
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            struct_data: self.struct_data.map(|v| v.to_proto()).transpose()?,
        })
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::FromProto<crate::model::answer::reference::UnstructuredDocumentInfo>
    for answer::reference::UnstructuredDocumentInfo
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::answer::reference::UnstructuredDocumentInfo,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::answer::reference::UnstructuredDocumentInfo::new()
                .set_document(self.document)
                .set_uri(self.uri)
                .set_title(self.title)
                .set_chunk_contents(
                    self.chunk_contents
                        .into_iter()
                        .map(|v| v.cnv())
                        .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
                )
                .set_or_clear_struct_data(self.struct_data.map(|v| v.cnv()).transpose()?),
        )
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::ToProto<answer::reference::chunk_info::DocumentMetadata>
    for crate::model::answer::reference::chunk_info::DocumentMetadata
{
    type Output = answer::reference::chunk_info::DocumentMetadata;
    fn to_proto(
        self,
    ) -> std::result::Result<
        answer::reference::chunk_info::DocumentMetadata,
        gaxi::prost::ConvertError,
    > {
        Ok(Self::Output {
            document: self.document.to_proto()?,
            uri: self.uri.to_proto()?,
            title: self.title.to_proto()?,
            page_identifier: self.page_identifier.to_proto()?,
            struct_data: self.struct_data.map(|v| v.to_proto()).transpose()?,
        })
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::FromProto<crate::model::answer::reference::chunk_info::DocumentMetadata>
    for answer::reference::chunk_info::DocumentMetadata
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::answer::reference::chunk_info::DocumentMetadata,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::answer::reference::chunk_info::DocumentMetadata::new()
                .set_document(self.document)
                .set_uri(self.uri)
                .set_title(self.title)
                .set_page_identifier(self.page_identifier)
                .set_or_clear_struct_data(self.struct_data.map(|v| v.cnv()).transpose()?),
        )
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::ToProto<answer::reference::ChunkInfo>
    for crate::model::answer::reference::ChunkInfo
{
    type Output = answer::reference::ChunkInfo;
    fn to_proto(
        self,
    ) -> std::result::Result<answer::reference::ChunkInfo, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            chunk: self.chunk.to_proto()?,
            content: self.content.to_proto()?,
            relevance_score: self.relevance_score.map(|v| v.to_proto()).transpose()?,
            document_metadata: self.document_metadata.map(|v| v.to_proto()).transpose()?,
        })
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::FromProto<crate::model::answer::reference::ChunkInfo>
    for answer::reference::ChunkInfo
{
    fn cnv(
        self,
    ) -> std::result::Result<crate::model::answer::reference::ChunkInfo, gaxi::prost::ConvertError>
    {
        Ok(crate::model::answer::reference::ChunkInfo::new()
            .set_chunk(self.chunk)
            .set_content(self.content)
            .set_or_clear_relevance_score(self.relevance_score.map(|v| v.cnv()).transpose()?)
            .set_or_clear_document_metadata(self.document_metadata.map(|v| v.cnv()).transpose()?))
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::ToProto<answer::reference::StructuredDocumentInfo>
    for crate::model::answer::reference::StructuredDocumentInfo
{
    type Output = answer::reference::StructuredDocumentInfo;
    fn to_proto(
        self,
    ) -> std::result::Result<answer::reference::StructuredDocumentInfo, gaxi::prost::ConvertError>
    {
        Ok(Self::Output {
            document: self.document.to_proto()?,
            struct_data: self.struct_data.map(|v| v.to_proto()).transpose()?,
            title: self.title.to_proto()?,
            uri: self.uri.to_proto()?,
        })
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::FromProto<crate::model::answer::reference::StructuredDocumentInfo>
    for answer::reference::StructuredDocumentInfo
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::answer::reference::StructuredDocumentInfo,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::answer::reference::StructuredDocumentInfo::new()
                .set_document(self.document)
                .set_or_clear_struct_data(self.struct_data.map(|v| v.cnv()).transpose()?)
                .set_title(self.title)
                .set_uri(self.uri),
        )
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::ToProto<answer::reference::Content> for crate::model::answer::reference::Content {
    type Output = answer::reference::Content;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        match self {
            Self::UnstructuredDocumentInfo(v) => {
                Ok(Self::Output::UnstructuredDocumentInfo((*v).to_proto()?))
            }
            Self::ChunkInfo(v) => Ok(Self::Output::ChunkInfo((*v).to_proto()?)),
            Self::StructuredDocumentInfo(v) => {
                Ok(Self::Output::StructuredDocumentInfo((*v).to_proto()?))
            }
        }
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::FromProto<crate::model::answer::reference::Content>
    for answer::reference::Content
{
    fn cnv(
        self,
    ) -> std::result::Result<crate::model::answer::reference::Content, gaxi::prost::ConvertError>
    {
        use crate::model::answer::reference::Content as T;
        match self {
            Self::UnstructuredDocumentInfo(v) => {
                Ok(T::UnstructuredDocumentInfo(std::boxed::Box::new(v.cnv()?)))
            }
            Self::ChunkInfo(v) => Ok(T::ChunkInfo(std::boxed::Box::new(v.cnv()?))),
            Self::StructuredDocumentInfo(v) => {
                Ok(T::StructuredDocumentInfo(std::boxed::Box::new(v.cnv()?)))
            }
        }
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::ToProto<answer::Reference> for crate::model::answer::Reference {
    type Output = answer::Reference;
    fn to_proto(self) -> std::result::Result<answer::Reference, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            content: self.content.map(|v| v.to_proto()).transpose()?,
        })
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::FromProto<crate::model::answer::Reference> for answer::Reference {
    fn cnv(
        self,
    ) -> std::result::Result<crate::model::answer::Reference, gaxi::prost::ConvertError> {
        Ok(crate::model::answer::Reference::new()
            .set_content(self.content.map(|v| v.cnv()).transpose()?))
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::ToProto<answer::step::action::SearchAction>
    for crate::model::answer::step::action::SearchAction
{
    type Output = answer::step::action::SearchAction;
    fn to_proto(
        self,
    ) -> std::result::Result<answer::step::action::SearchAction, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            query: self.query.to_proto()?,
        })
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::FromProto<crate::model::answer::step::action::SearchAction>
    for answer::step::action::SearchAction
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::answer::step::action::SearchAction,
        gaxi::prost::ConvertError,
    > {
        Ok(crate::model::answer::step::action::SearchAction::new().set_query(self.query))
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::ToProto<answer::step::action::observation::search_result::SnippetInfo>
    for crate::model::answer::step::action::observation::search_result::SnippetInfo
{
    type Output = answer::step::action::observation::search_result::SnippetInfo;
    fn to_proto(
        self,
    ) -> std::result::Result<
        answer::step::action::observation::search_result::SnippetInfo,
        gaxi::prost::ConvertError,
    > {
        Ok(Self::Output {
            snippet: self.snippet.to_proto()?,
            snippet_status: self.snippet_status.to_proto()?,
        })
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl
    gaxi::prost::FromProto<
        crate::model::answer::step::action::observation::search_result::SnippetInfo,
    > for answer::step::action::observation::search_result::SnippetInfo
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::answer::step::action::observation::search_result::SnippetInfo,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::answer::step::action::observation::search_result::SnippetInfo::new()
                .set_snippet(self.snippet)
                .set_snippet_status(self.snippet_status),
        )
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::ToProto<answer::step::action::observation::search_result::ChunkInfo>
    for crate::model::answer::step::action::observation::search_result::ChunkInfo
{
    type Output = answer::step::action::observation::search_result::ChunkInfo;
    fn to_proto(
        self,
    ) -> std::result::Result<
        answer::step::action::observation::search_result::ChunkInfo,
        gaxi::prost::ConvertError,
    > {
        Ok(Self::Output {
            chunk: self.chunk.to_proto()?,
            content: self.content.to_proto()?,
            relevance_score: self.relevance_score.map(|v| v.to_proto()).transpose()?,
        })
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl
    gaxi::prost::FromProto<
        crate::model::answer::step::action::observation::search_result::ChunkInfo,
    > for answer::step::action::observation::search_result::ChunkInfo
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::answer::step::action::observation::search_result::ChunkInfo,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::answer::step::action::observation::search_result::ChunkInfo::new()
                .set_chunk(self.chunk)
                .set_content(self.content)
                .set_or_clear_relevance_score(self.relevance_score.map(|v| v.cnv()).transpose()?),
        )
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::ToProto<answer::step::action::observation::SearchResult>
    for crate::model::answer::step::action::observation::SearchResult
{
    type Output = answer::step::action::observation::SearchResult;
    fn to_proto(
        self,
    ) -> std::result::Result<
        answer::step::action::observation::SearchResult,
        gaxi::prost::ConvertError,
    > {
        Ok(Self::Output {
            document: self.document.to_proto()?,
            uri: self.uri.to_proto()?,
            title: self.title.to_proto()?,
            snippet_info: self
                .snippet_info
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            chunk_info: self
                .chunk_info
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            struct_data: self.struct_data.map(|v| v.to_proto()).transpose()?,
        })
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::FromProto<crate::model::answer::step::action::observation::SearchResult>
    for answer::step::action::observation::SearchResult
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::answer::step::action::observation::SearchResult,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::answer::step::action::observation::SearchResult::new()
                .set_document(self.document)
                .set_uri(self.uri)
                .set_title(self.title)
                .set_snippet_info(
                    self.snippet_info
                        .into_iter()
                        .map(|v| v.cnv())
                        .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
                )
                .set_chunk_info(
                    self.chunk_info
                        .into_iter()
                        .map(|v| v.cnv())
                        .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
                )
                .set_or_clear_struct_data(self.struct_data.map(|v| v.cnv()).transpose()?),
        )
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::ToProto<answer::step::action::Observation>
    for crate::model::answer::step::action::Observation
{
    type Output = answer::step::action::Observation;
    fn to_proto(
        self,
    ) -> std::result::Result<answer::step::action::Observation, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            search_results: self
                .search_results
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
        })
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::FromProto<crate::model::answer::step::action::Observation>
    for answer::step::action::Observation
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::answer::step::action::Observation,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::answer::step::action::Observation::new().set_search_results(
                self.search_results
                    .into_iter()
                    .map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            ),
        )
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::ToProto<answer::step::action::Action>
    for crate::model::answer::step::action::Action
{
    type Output = answer::step::action::Action;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        match self {
            Self::SearchAction(v) => Ok(Self::Output::SearchAction((*v).to_proto()?)),
        }
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::FromProto<crate::model::answer::step::action::Action>
    for answer::step::action::Action
{
    fn cnv(
        self,
    ) -> std::result::Result<crate::model::answer::step::action::Action, gaxi::prost::ConvertError>
    {
        use crate::model::answer::step::action::Action as T;
        match self {
            Self::SearchAction(v) => Ok(T::SearchAction(std::boxed::Box::new(v.cnv()?))),
        }
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::ToProto<answer::step::Action> for crate::model::answer::step::Action {
    type Output = answer::step::Action;
    fn to_proto(self) -> std::result::Result<answer::step::Action, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            observation: self.observation.map(|v| v.to_proto()).transpose()?,
            action: self.action.map(|v| v.to_proto()).transpose()?,
        })
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::FromProto<crate::model::answer::step::Action> for answer::step::Action {
    fn cnv(
        self,
    ) -> std::result::Result<crate::model::answer::step::Action, gaxi::prost::ConvertError> {
        Ok(crate::model::answer::step::Action::new()
            .set_or_clear_observation(self.observation.map(|v| v.cnv()).transpose()?)
            .set_action(self.action.map(|v| v.cnv()).transpose()?))
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::ToProto<answer::step::State> for crate::model::answer::step::State {
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value()
            .ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue(
                "crate::model::answer::step::State",
            ))
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::ToProto<answer::Step> for crate::model::answer::Step {
    type Output = answer::Step;
    fn to_proto(self) -> std::result::Result<answer::Step, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            state: self.state.to_proto()?,
            description: self.description.to_proto()?,
            thought: self.thought.to_proto()?,
            actions: self
                .actions
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
        })
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::FromProto<crate::model::answer::Step> for answer::Step {
    fn cnv(self) -> std::result::Result<crate::model::answer::Step, gaxi::prost::ConvertError> {
        Ok(crate::model::answer::Step::new()
            .set_state(self.state)
            .set_description(self.description)
            .set_thought(self.thought)
            .set_actions(
                self.actions
                    .into_iter()
                    .map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            ))
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::ToProto<answer::query_understanding_info::query_classification_info::Type>
    for crate::model::answer::query_understanding_info::query_classification_info::Type
{
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value()
            .ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue(
                "crate::model::answer::query_understanding_info::query_classification_info::Type",
            ))
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::ToProto<answer::query_understanding_info::QueryClassificationInfo>
    for crate::model::answer::query_understanding_info::QueryClassificationInfo
{
    type Output = answer::query_understanding_info::QueryClassificationInfo;
    fn to_proto(
        self,
    ) -> std::result::Result<
        answer::query_understanding_info::QueryClassificationInfo,
        gaxi::prost::ConvertError,
    > {
        Ok(Self::Output {
            r#type: self.r#type.to_proto()?,
            positive: self.positive.to_proto()?,
        })
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::FromProto<crate::model::answer::query_understanding_info::QueryClassificationInfo>
    for answer::query_understanding_info::QueryClassificationInfo
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::answer::query_understanding_info::QueryClassificationInfo,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::answer::query_understanding_info::QueryClassificationInfo::new()
                .set_type(self.r#type)
                .set_positive(self.positive),
        )
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::ToProto<answer::QueryUnderstandingInfo>
    for crate::model::answer::QueryUnderstandingInfo
{
    type Output = answer::QueryUnderstandingInfo;
    fn to_proto(
        self,
    ) -> std::result::Result<answer::QueryUnderstandingInfo, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            query_classification_info: self
                .query_classification_info
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
        })
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::FromProto<crate::model::answer::QueryUnderstandingInfo>
    for answer::QueryUnderstandingInfo
{
    fn cnv(
        self,
    ) -> std::result::Result<crate::model::answer::QueryUnderstandingInfo, gaxi::prost::ConvertError>
    {
        Ok(
            crate::model::answer::QueryUnderstandingInfo::new().set_query_classification_info(
                self.query_classification_info
                    .into_iter()
                    .map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            ),
        )
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::ToProto<answer::State> for crate::model::answer::State {
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value()
            .ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue(
                "crate::model::answer::State",
            ))
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::ToProto<answer::AnswerSkippedReason>
    for crate::model::answer::AnswerSkippedReason
{
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value()
            .ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue(
                "crate::model::answer::AnswerSkippedReason",
            ))
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::ToProto<Answer> for crate::model::Answer {
    type Output = Answer;
    fn to_proto(self) -> std::result::Result<Answer, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            name: self.name.to_proto()?,
            state: self.state.to_proto()?,
            answer_text: self.answer_text.to_proto()?,
            grounding_score: self.grounding_score.map(|v| v.to_proto()).transpose()?,
            citations: self
                .citations
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            grounding_supports: self
                .grounding_supports
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            references: self
                .references
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            related_questions: self
                .related_questions
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            steps: self
                .steps
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            query_understanding_info: self
                .query_understanding_info
                .map(|v| v.to_proto())
                .transpose()?,
            answer_skipped_reasons: self
                .answer_skipped_reasons
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            create_time: self.create_time.map(|v| v.to_proto()).transpose()?,
            complete_time: self.complete_time.map(|v| v.to_proto()).transpose()?,
            safety_ratings: self
                .safety_ratings
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
        })
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::FromProto<crate::model::Answer> for Answer {
    fn cnv(self) -> std::result::Result<crate::model::Answer, gaxi::prost::ConvertError> {
        Ok(crate::model::Answer::new()
            .set_name(self.name)
            .set_state(self.state)
            .set_answer_text(self.answer_text)
            .set_or_clear_grounding_score(self.grounding_score.map(|v| v.cnv()).transpose()?)
            .set_citations(
                self.citations
                    .into_iter()
                    .map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            )
            .set_grounding_supports(
                self.grounding_supports
                    .into_iter()
                    .map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            )
            .set_references(
                self.references
                    .into_iter()
                    .map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            )
            .set_related_questions(
                self.related_questions
                    .into_iter()
                    .map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            )
            .set_steps(
                self.steps
                    .into_iter()
                    .map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            )
            .set_or_clear_query_understanding_info(
                self.query_understanding_info.map(|v| v.cnv()).transpose()?,
            )
            .set_answer_skipped_reasons(
                self.answer_skipped_reasons
                    .into_iter()
                    .map(crate::model::answer::AnswerSkippedReason::from),
            )
            .set_or_clear_create_time(self.create_time.map(|v| v.cnv()).transpose()?)
            .set_or_clear_complete_time(self.complete_time.map(|v| v.cnv()).transpose()?)
            .set_safety_ratings(
                self.safety_ratings
                    .into_iter()
                    .map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            ))
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl gaxi::prost::ToProto<assist_answer::reply::Reply>
    for crate::model::assist_answer::reply::Reply
{
    type Output = assist_answer::reply::Reply;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        match self {
            Self::GroundedContent(v) => Ok(Self::Output::GroundedContent((*v).to_proto()?)),
        }
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl gaxi::prost::FromProto<crate::model::assist_answer::reply::Reply>
    for assist_answer::reply::Reply
{
    fn cnv(
        self,
    ) -> std::result::Result<crate::model::assist_answer::reply::Reply, gaxi::prost::ConvertError>
    {
        use crate::model::assist_answer::reply::Reply as T;
        match self {
            Self::GroundedContent(v) => Ok(T::GroundedContent(std::boxed::Box::new(v.cnv()?))),
        }
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl gaxi::prost::ToProto<assist_answer::Reply> for crate::model::assist_answer::Reply {
    type Output = assist_answer::Reply;
    fn to_proto(self) -> std::result::Result<assist_answer::Reply, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            reply: self.reply.map(|v| v.to_proto()).transpose()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl gaxi::prost::FromProto<crate::model::assist_answer::Reply> for assist_answer::Reply {
    fn cnv(
        self,
    ) -> std::result::Result<crate::model::assist_answer::Reply, gaxi::prost::ConvertError> {
        Ok(crate::model::assist_answer::Reply::new()
            .set_reply(self.reply.map(|v| v.cnv()).transpose()?))
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl gaxi::prost::ToProto<assist_answer::State> for crate::model::assist_answer::State {
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value()
            .ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue(
                "crate::model::assist_answer::State",
            ))
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl gaxi::prost::ToProto<assist_answer::AssistSkippedReason>
    for crate::model::assist_answer::AssistSkippedReason
{
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value()
            .ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue(
                "crate::model::assist_answer::AssistSkippedReason",
            ))
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl gaxi::prost::ToProto<AssistAnswer> for crate::model::AssistAnswer {
    type Output = AssistAnswer;
    fn to_proto(self) -> std::result::Result<AssistAnswer, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            name: self.name.to_proto()?,
            state: self.state.to_proto()?,
            replies: self
                .replies
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            assist_skipped_reasons: self
                .assist_skipped_reasons
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl gaxi::prost::FromProto<crate::model::AssistAnswer> for AssistAnswer {
    fn cnv(self) -> std::result::Result<crate::model::AssistAnswer, gaxi::prost::ConvertError> {
        Ok(crate::model::AssistAnswer::new()
            .set_name(self.name)
            .set_state(self.state)
            .set_replies(
                self.replies
                    .into_iter()
                    .map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            )
            .set_assist_skipped_reasons(
                self.assist_skipped_reasons
                    .into_iter()
                    .map(crate::model::assist_answer::AssistSkippedReason::from),
            ))
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl gaxi::prost::ToProto<assistant_content::Blob> for crate::model::assistant_content::Blob {
    type Output = assistant_content::Blob;
    fn to_proto(self) -> std::result::Result<assistant_content::Blob, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            mime_type: self.mime_type.to_proto()?,
            data: self.data.to_proto()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl gaxi::prost::FromProto<crate::model::assistant_content::Blob> for assistant_content::Blob {
    fn cnv(
        self,
    ) -> std::result::Result<crate::model::assistant_content::Blob, gaxi::prost::ConvertError> {
        Ok(crate::model::assistant_content::Blob::new()
            .set_mime_type(self.mime_type)
            .set_data(self.data))
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl gaxi::prost::ToProto<assistant_content::File> for crate::model::assistant_content::File {
    type Output = assistant_content::File;
    fn to_proto(self) -> std::result::Result<assistant_content::File, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            mime_type: self.mime_type.to_proto()?,
            file_id: self.file_id.to_proto()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl gaxi::prost::FromProto<crate::model::assistant_content::File> for assistant_content::File {
    fn cnv(
        self,
    ) -> std::result::Result<crate::model::assistant_content::File, gaxi::prost::ConvertError> {
        Ok(crate::model::assistant_content::File::new()
            .set_mime_type(self.mime_type)
            .set_file_id(self.file_id))
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl gaxi::prost::ToProto<assistant_content::ExecutableCode>
    for crate::model::assistant_content::ExecutableCode
{
    type Output = assistant_content::ExecutableCode;
    fn to_proto(
        self,
    ) -> std::result::Result<assistant_content::ExecutableCode, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            code: self.code.to_proto()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl gaxi::prost::FromProto<crate::model::assistant_content::ExecutableCode>
    for assistant_content::ExecutableCode
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::assistant_content::ExecutableCode,
        gaxi::prost::ConvertError,
    > {
        Ok(crate::model::assistant_content::ExecutableCode::new().set_code(self.code))
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl gaxi::prost::ToProto<assistant_content::code_execution_result::Outcome>
    for crate::model::assistant_content::code_execution_result::Outcome
{
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value()
            .ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue(
                "crate::model::assistant_content::code_execution_result::Outcome",
            ))
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl gaxi::prost::ToProto<assistant_content::CodeExecutionResult>
    for crate::model::assistant_content::CodeExecutionResult
{
    type Output = assistant_content::CodeExecutionResult;
    fn to_proto(
        self,
    ) -> std::result::Result<assistant_content::CodeExecutionResult, gaxi::prost::ConvertError>
    {
        Ok(Self::Output {
            outcome: self.outcome.to_proto()?,
            output: self.output.to_proto()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl gaxi::prost::FromProto<crate::model::assistant_content::CodeExecutionResult>
    for assistant_content::CodeExecutionResult
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::assistant_content::CodeExecutionResult,
        gaxi::prost::ConvertError,
    > {
        Ok(crate::model::assistant_content::CodeExecutionResult::new()
            .set_outcome(self.outcome)
            .set_output(self.output))
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl gaxi::prost::ToProto<assistant_content::Data> for crate::model::assistant_content::Data {
    type Output = assistant_content::Data;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        match self {
            Self::Text(v) => Ok(Self::Output::Text(v.to_proto()?)),
            Self::InlineData(v) => Ok(Self::Output::InlineData((*v).to_proto()?)),
            Self::File(v) => Ok(Self::Output::File((*v).to_proto()?)),
            Self::ExecutableCode(v) => Ok(Self::Output::ExecutableCode((*v).to_proto()?)),
            Self::CodeExecutionResult(v) => Ok(Self::Output::CodeExecutionResult((*v).to_proto()?)),
        }
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl gaxi::prost::FromProto<crate::model::assistant_content::Data> for assistant_content::Data {
    fn cnv(
        self,
    ) -> std::result::Result<crate::model::assistant_content::Data, gaxi::prost::ConvertError> {
        use crate::model::assistant_content::Data as T;
        match self {
            Self::Text(v) => Ok(T::Text(v.cnv()?)),
            Self::InlineData(v) => Ok(T::InlineData(std::boxed::Box::new(v.cnv()?))),
            Self::File(v) => Ok(T::File(std::boxed::Box::new(v.cnv()?))),
            Self::ExecutableCode(v) => Ok(T::ExecutableCode(std::boxed::Box::new(v.cnv()?))),
            Self::CodeExecutionResult(v) => {
                Ok(T::CodeExecutionResult(std::boxed::Box::new(v.cnv()?)))
            }
        }
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl gaxi::prost::ToProto<AssistantContent> for crate::model::AssistantContent {
    type Output = AssistantContent;
    fn to_proto(self) -> std::result::Result<AssistantContent, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            role: self.role.to_proto()?,
            thought: self.thought.to_proto()?,
            data: self.data.map(|v| v.to_proto()).transpose()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl gaxi::prost::FromProto<crate::model::AssistantContent> for AssistantContent {
    fn cnv(self) -> std::result::Result<crate::model::AssistantContent, gaxi::prost::ConvertError> {
        Ok(crate::model::AssistantContent::new()
            .set_role(self.role)
            .set_thought(self.thought)
            .set_data(self.data.map(|v| v.cnv()).transpose()?))
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl gaxi::prost::ToProto<assistant_grounded_content::text_grounding_metadata::Segment>
    for crate::model::assistant_grounded_content::text_grounding_metadata::Segment
{
    type Output = assistant_grounded_content::text_grounding_metadata::Segment;
    fn to_proto(
        self,
    ) -> std::result::Result<
        assistant_grounded_content::text_grounding_metadata::Segment,
        gaxi::prost::ConvertError,
    > {
        Ok(Self::Output {
            start_index: self.start_index.to_proto()?,
            end_index: self.end_index.to_proto()?,
            reference_indices: self
                .reference_indices
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            grounding_score: self.grounding_score.to_proto()?,
            text: self.text.to_proto()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl
    gaxi::prost::FromProto<
        crate::model::assistant_grounded_content::text_grounding_metadata::Segment,
    > for assistant_grounded_content::text_grounding_metadata::Segment
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::assistant_grounded_content::text_grounding_metadata::Segment,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::assistant_grounded_content::text_grounding_metadata::Segment::new()
                .set_start_index(self.start_index)
                .set_end_index(self.end_index)
                .set_reference_indices(
                    self.reference_indices
                        .into_iter()
                        .map(|v| v.cnv())
                        .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
                )
                .set_grounding_score(self.grounding_score)
                .set_text(self.text),
        )
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl gaxi::prost::ToProto<assistant_grounded_content::text_grounding_metadata::reference::DocumentMetadata> for crate::model::assistant_grounded_content::text_grounding_metadata::reference::DocumentMetadata {
    type Output = assistant_grounded_content::text_grounding_metadata::reference::DocumentMetadata;
    fn to_proto(self) -> std::result::Result<assistant_grounded_content::text_grounding_metadata::reference::DocumentMetadata, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            document: self.document.map(|v| v.to_proto()).transpose()?,
            uri: self.uri.map(|v| v.to_proto()).transpose()?,
            title: self.title.map(|v| v.to_proto()).transpose()?,
            page_identifier: self.page_identifier.map(|v| v.to_proto()).transpose()?,
            domain: self.domain.map(|v| v.to_proto()).transpose()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl gaxi::prost::FromProto<crate::model::assistant_grounded_content::text_grounding_metadata::reference::DocumentMetadata> for assistant_grounded_content::text_grounding_metadata::reference::DocumentMetadata {
    fn cnv(self) -> std::result::Result<crate::model::assistant_grounded_content::text_grounding_metadata::reference::DocumentMetadata, gaxi::prost::ConvertError> {
        Ok(
            crate::model::assistant_grounded_content::text_grounding_metadata::reference::DocumentMetadata::new()
                .set_or_clear_document(self.document.map(|v| v.cnv()).transpose()?)
                .set_or_clear_uri(self.uri.map(|v| v.cnv()).transpose()?)
                .set_or_clear_title(self.title.map(|v| v.cnv()).transpose()?)
                .set_or_clear_page_identifier(self.page_identifier.map(|v| v.cnv()).transpose()?)
                .set_or_clear_domain(self.domain.map(|v| v.cnv()).transpose()?)
        )
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl gaxi::prost::ToProto<assistant_grounded_content::text_grounding_metadata::Reference>
    for crate::model::assistant_grounded_content::text_grounding_metadata::Reference
{
    type Output = assistant_grounded_content::text_grounding_metadata::Reference;
    fn to_proto(
        self,
    ) -> std::result::Result<
        assistant_grounded_content::text_grounding_metadata::Reference,
        gaxi::prost::ConvertError,
    > {
        Ok(Self::Output {
            content: self.content.to_proto()?,
            document_metadata: self.document_metadata.map(|v| v.to_proto()).transpose()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl
    gaxi::prost::FromProto<
        crate::model::assistant_grounded_content::text_grounding_metadata::Reference,
    > for assistant_grounded_content::text_grounding_metadata::Reference
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::assistant_grounded_content::text_grounding_metadata::Reference,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::assistant_grounded_content::text_grounding_metadata::Reference::new()
                .set_content(self.content)
                .set_or_clear_document_metadata(
                    self.document_metadata.map(|v| v.cnv()).transpose()?,
                ),
        )
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl gaxi::prost::ToProto<assistant_grounded_content::TextGroundingMetadata>
    for crate::model::assistant_grounded_content::TextGroundingMetadata
{
    type Output = assistant_grounded_content::TextGroundingMetadata;
    fn to_proto(
        self,
    ) -> std::result::Result<
        assistant_grounded_content::TextGroundingMetadata,
        gaxi::prost::ConvertError,
    > {
        Ok(Self::Output {
            segments: self
                .segments
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            references: self
                .references
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl gaxi::prost::FromProto<crate::model::assistant_grounded_content::TextGroundingMetadata>
    for assistant_grounded_content::TextGroundingMetadata
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::assistant_grounded_content::TextGroundingMetadata,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::assistant_grounded_content::TextGroundingMetadata::new()
                .set_segments(
                    self.segments
                        .into_iter()
                        .map(|v| v.cnv())
                        .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
                )
                .set_references(
                    self.references
                        .into_iter()
                        .map(|v| v.cnv())
                        .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
                ),
        )
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl gaxi::prost::ToProto<assistant_grounded_content::Metadata>
    for crate::model::assistant_grounded_content::Metadata
{
    type Output = assistant_grounded_content::Metadata;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        match self {
            Self::TextGroundingMetadata(v) => {
                Ok(Self::Output::TextGroundingMetadata((*v).to_proto()?))
            }
        }
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl gaxi::prost::FromProto<crate::model::assistant_grounded_content::Metadata>
    for assistant_grounded_content::Metadata
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::assistant_grounded_content::Metadata,
        gaxi::prost::ConvertError,
    > {
        use crate::model::assistant_grounded_content::Metadata as T;
        match self {
            Self::TextGroundingMetadata(v) => {
                Ok(T::TextGroundingMetadata(std::boxed::Box::new(v.cnv()?)))
            }
        }
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl gaxi::prost::ToProto<AssistantGroundedContent> for crate::model::AssistantGroundedContent {
    type Output = AssistantGroundedContent;
    fn to_proto(self) -> std::result::Result<AssistantGroundedContent, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            content: self.content.map(|v| v.to_proto()).transpose()?,
            metadata: self.metadata.map(|v| v.to_proto()).transpose()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl gaxi::prost::FromProto<crate::model::AssistantGroundedContent> for AssistantGroundedContent {
    fn cnv(
        self,
    ) -> std::result::Result<crate::model::AssistantGroundedContent, gaxi::prost::ConvertError>
    {
        Ok(crate::model::AssistantGroundedContent::new()
            .set_or_clear_content(self.content.map(|v| v.cnv()).transpose()?)
            .set_metadata(self.metadata.map(|v| v.cnv()).transpose()?))
    }
}

#[cfg(feature = "assistant-service")]
impl gaxi::prost::ToProto<AssistUserMetadata> for crate::model::AssistUserMetadata {
    type Output = AssistUserMetadata;
    fn to_proto(self) -> std::result::Result<AssistUserMetadata, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            time_zone: self.time_zone.to_proto()?,
            preferred_language_code: self.preferred_language_code.to_proto()?,
        })
    }
}

#[cfg(feature = "assistant-service")]
impl gaxi::prost::FromProto<crate::model::AssistUserMetadata> for AssistUserMetadata {
    fn cnv(
        self,
    ) -> std::result::Result<crate::model::AssistUserMetadata, gaxi::prost::ConvertError> {
        Ok(crate::model::AssistUserMetadata::new()
            .set_time_zone(self.time_zone)
            .set_preferred_language_code(self.preferred_language_code))
    }
}

#[cfg(feature = "assistant-service")]
impl gaxi::prost::ToProto<stream_assist_request::agents_spec::AgentSpec>
    for crate::model::stream_assist_request::agents_spec::AgentSpec
{
    type Output = stream_assist_request::agents_spec::AgentSpec;
    fn to_proto(
        self,
    ) -> std::result::Result<stream_assist_request::agents_spec::AgentSpec, gaxi::prost::ConvertError>
    {
        Ok(Self::Output {
            agent_id: self.agent_id.to_proto()?,
        })
    }
}

#[cfg(feature = "assistant-service")]
impl gaxi::prost::FromProto<crate::model::stream_assist_request::agents_spec::AgentSpec>
    for stream_assist_request::agents_spec::AgentSpec
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::stream_assist_request::agents_spec::AgentSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::stream_assist_request::agents_spec::AgentSpec::new()
                .set_agent_id(self.agent_id),
        )
    }
}

#[cfg(feature = "assistant-service")]
impl gaxi::prost::ToProto<stream_assist_request::AgentsSpec>
    for crate::model::stream_assist_request::AgentsSpec
{
    type Output = stream_assist_request::AgentsSpec;
    fn to_proto(
        self,
    ) -> std::result::Result<stream_assist_request::AgentsSpec, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            agent_specs: self
                .agent_specs
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
        })
    }
}

#[cfg(feature = "assistant-service")]
impl gaxi::prost::FromProto<crate::model::stream_assist_request::AgentsSpec>
    for stream_assist_request::AgentsSpec
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::stream_assist_request::AgentsSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::stream_assist_request::AgentsSpec::new().set_agent_specs(
                self.agent_specs
                    .into_iter()
                    .map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            ),
        )
    }
}

#[cfg(feature = "assistant-service")]
impl gaxi::prost::ToProto<stream_assist_request::tools_spec::VertexAiSearchSpec>
    for crate::model::stream_assist_request::tools_spec::VertexAiSearchSpec
{
    type Output = stream_assist_request::tools_spec::VertexAiSearchSpec;
    fn to_proto(
        self,
    ) -> std::result::Result<
        stream_assist_request::tools_spec::VertexAiSearchSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(Self::Output {
            data_store_specs: self
                .data_store_specs
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            filter: self.filter.to_proto()?,
        })
    }
}

#[cfg(feature = "assistant-service")]
impl gaxi::prost::FromProto<crate::model::stream_assist_request::tools_spec::VertexAiSearchSpec>
    for stream_assist_request::tools_spec::VertexAiSearchSpec
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::stream_assist_request::tools_spec::VertexAiSearchSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::stream_assist_request::tools_spec::VertexAiSearchSpec::new()
                .set_data_store_specs(
                    self.data_store_specs
                        .into_iter()
                        .map(|v| v.cnv())
                        .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
                )
                .set_filter(self.filter),
        )
    }
}

#[cfg(feature = "assistant-service")]
impl gaxi::prost::ToProto<stream_assist_request::tools_spec::WebGroundingSpec>
    for crate::model::stream_assist_request::tools_spec::WebGroundingSpec
{
    type Output = stream_assist_request::tools_spec::WebGroundingSpec;
    fn to_proto(
        self,
    ) -> std::result::Result<
        stream_assist_request::tools_spec::WebGroundingSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(Self::Output {})
    }
}

#[cfg(feature = "assistant-service")]
impl gaxi::prost::FromProto<crate::model::stream_assist_request::tools_spec::WebGroundingSpec>
    for stream_assist_request::tools_spec::WebGroundingSpec
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::stream_assist_request::tools_spec::WebGroundingSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(crate::model::stream_assist_request::tools_spec::WebGroundingSpec::new())
    }
}

#[cfg(feature = "assistant-service")]
impl gaxi::prost::ToProto<stream_assist_request::tools_spec::ImageGenerationSpec>
    for crate::model::stream_assist_request::tools_spec::ImageGenerationSpec
{
    type Output = stream_assist_request::tools_spec::ImageGenerationSpec;
    fn to_proto(
        self,
    ) -> std::result::Result<
        stream_assist_request::tools_spec::ImageGenerationSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(Self::Output {})
    }
}

#[cfg(feature = "assistant-service")]
impl gaxi::prost::FromProto<crate::model::stream_assist_request::tools_spec::ImageGenerationSpec>
    for stream_assist_request::tools_spec::ImageGenerationSpec
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::stream_assist_request::tools_spec::ImageGenerationSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(crate::model::stream_assist_request::tools_spec::ImageGenerationSpec::new())
    }
}

#[cfg(feature = "assistant-service")]
impl gaxi::prost::ToProto<stream_assist_request::tools_spec::VideoGenerationSpec>
    for crate::model::stream_assist_request::tools_spec::VideoGenerationSpec
{
    type Output = stream_assist_request::tools_spec::VideoGenerationSpec;
    fn to_proto(
        self,
    ) -> std::result::Result<
        stream_assist_request::tools_spec::VideoGenerationSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(Self::Output {})
    }
}

#[cfg(feature = "assistant-service")]
impl gaxi::prost::FromProto<crate::model::stream_assist_request::tools_spec::VideoGenerationSpec>
    for stream_assist_request::tools_spec::VideoGenerationSpec
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::stream_assist_request::tools_spec::VideoGenerationSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(crate::model::stream_assist_request::tools_spec::VideoGenerationSpec::new())
    }
}

#[cfg(feature = "assistant-service")]
impl gaxi::prost::ToProto<stream_assist_request::ToolsSpec>
    for crate::model::stream_assist_request::ToolsSpec
{
    type Output = stream_assist_request::ToolsSpec;
    fn to_proto(
        self,
    ) -> std::result::Result<stream_assist_request::ToolsSpec, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            vertex_ai_search_spec: self
                .vertex_ai_search_spec
                .map(|v| v.to_proto())
                .transpose()?,
            web_grounding_spec: self.web_grounding_spec.map(|v| v.to_proto()).transpose()?,
            image_generation_spec: self
                .image_generation_spec
                .map(|v| v.to_proto())
                .transpose()?,
            video_generation_spec: self
                .video_generation_spec
                .map(|v| v.to_proto())
                .transpose()?,
        })
    }
}

#[cfg(feature = "assistant-service")]
impl gaxi::prost::FromProto<crate::model::stream_assist_request::ToolsSpec>
    for stream_assist_request::ToolsSpec
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::stream_assist_request::ToolsSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(crate::model::stream_assist_request::ToolsSpec::new()
            .set_or_clear_vertex_ai_search_spec(
                self.vertex_ai_search_spec.map(|v| v.cnv()).transpose()?,
            )
            .set_or_clear_web_grounding_spec(self.web_grounding_spec.map(|v| v.cnv()).transpose()?)
            .set_or_clear_image_generation_spec(
                self.image_generation_spec.map(|v| v.cnv()).transpose()?,
            )
            .set_or_clear_video_generation_spec(
                self.video_generation_spec.map(|v| v.cnv()).transpose()?,
            ))
    }
}

#[cfg(feature = "assistant-service")]
impl gaxi::prost::ToProto<stream_assist_request::GenerationSpec>
    for crate::model::stream_assist_request::GenerationSpec
{
    type Output = stream_assist_request::GenerationSpec;
    fn to_proto(
        self,
    ) -> std::result::Result<stream_assist_request::GenerationSpec, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            model_id: self.model_id.to_proto()?,
        })
    }
}

#[cfg(feature = "assistant-service")]
impl gaxi::prost::FromProto<crate::model::stream_assist_request::GenerationSpec>
    for stream_assist_request::GenerationSpec
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::stream_assist_request::GenerationSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(crate::model::stream_assist_request::GenerationSpec::new().set_model_id(self.model_id))
    }
}

#[cfg(feature = "assistant-service")]
impl gaxi::prost::ToProto<StreamAssistRequest> for crate::model::StreamAssistRequest {
    type Output = StreamAssistRequest;
    fn to_proto(self) -> std::result::Result<StreamAssistRequest, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            name: self.name.to_proto()?,
            query: self.query.map(|v| v.to_proto()).transpose()?,
            session: self.session.to_proto()?,
            user_metadata: self.user_metadata.map(|v| v.to_proto()).transpose()?,
            agents_spec: self.agents_spec.map(|v| v.to_proto()).transpose()?,
            tools_spec: self.tools_spec.map(|v| v.to_proto()).transpose()?,
            generation_spec: self.generation_spec.map(|v| v.to_proto()).transpose()?,
        })
    }
}

#[cfg(feature = "assistant-service")]
impl gaxi::prost::FromProto<crate::model::StreamAssistRequest> for StreamAssistRequest {
    fn cnv(
        self,
    ) -> std::result::Result<crate::model::StreamAssistRequest, gaxi::prost::ConvertError> {
        Ok(crate::model::StreamAssistRequest::new()
            .set_name(self.name)
            .set_or_clear_query(self.query.map(|v| v.cnv()).transpose()?)
            .set_session(self.session)
            .set_or_clear_user_metadata(self.user_metadata.map(|v| v.cnv()).transpose()?)
            .set_or_clear_agents_spec(self.agents_spec.map(|v| v.cnv()).transpose()?)
            .set_or_clear_tools_spec(self.tools_spec.map(|v| v.cnv()).transpose()?)
            .set_or_clear_generation_spec(self.generation_spec.map(|v| v.cnv()).transpose()?))
    }
}

#[cfg(feature = "assistant-service")]
impl gaxi::prost::ToProto<stream_assist_response::SessionInfo>
    for crate::model::stream_assist_response::SessionInfo
{
    type Output = stream_assist_response::SessionInfo;
    fn to_proto(
        self,
    ) -> std::result::Result<stream_assist_response::SessionInfo, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            session: self.session.to_proto()?,
        })
    }
}

#[cfg(feature = "assistant-service")]
impl gaxi::prost::FromProto<crate::model::stream_assist_response::SessionInfo>
    for stream_assist_response::SessionInfo
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::stream_assist_response::SessionInfo,
        gaxi::prost::ConvertError,
    > {
        Ok(crate::model::stream_assist_response::SessionInfo::new().set_session(self.session))
    }
}

#[cfg(feature = "assistant-service")]
impl gaxi::prost::ToProto<StreamAssistResponse> for crate::model::StreamAssistResponse {
    type Output = StreamAssistResponse;
    fn to_proto(self) -> std::result::Result<StreamAssistResponse, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            answer: self.answer.map(|v| v.to_proto()).transpose()?,
            session_info: self.session_info.map(|v| v.to_proto()).transpose()?,
            assist_token: self.assist_token.to_proto()?,
        })
    }
}

#[cfg(feature = "assistant-service")]
impl gaxi::prost::FromProto<crate::model::StreamAssistResponse> for StreamAssistResponse {
    fn cnv(
        self,
    ) -> std::result::Result<crate::model::StreamAssistResponse, gaxi::prost::ConvertError> {
        Ok(crate::model::StreamAssistResponse::new()
            .set_or_clear_answer(self.answer.map(|v| v.cnv()).transpose()?)
            .set_or_clear_session_info(self.session_info.map(|v| v.cnv()).transpose()?)
            .set_assist_token(self.assist_token))
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<interval::Min> for crate::model::interval::Min {
    type Output = interval::Min;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        match self {
            Self::Minimum(v) => Ok(Self::Output::Minimum(v.to_proto()?)),
            Self::ExclusiveMinimum(v) => Ok(Self::Output::ExclusiveMinimum(v.to_proto()?)),
        }
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::FromProto<crate::model::interval::Min> for interval::Min {
    fn cnv(self) -> std::result::Result<crate::model::interval::Min, gaxi::prost::ConvertError> {
        use crate::model::interval::Min as T;
        match self {
            Self::Minimum(v) => Ok(T::Minimum(v.cnv()?)),
            Self::ExclusiveMinimum(v) => Ok(T::ExclusiveMinimum(v.cnv()?)),
        }
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<interval::Max> for crate::model::interval::Max {
    type Output = interval::Max;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        match self {
            Self::Maximum(v) => Ok(Self::Output::Maximum(v.to_proto()?)),
            Self::ExclusiveMaximum(v) => Ok(Self::Output::ExclusiveMaximum(v.to_proto()?)),
        }
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::FromProto<crate::model::interval::Max> for interval::Max {
    fn cnv(self) -> std::result::Result<crate::model::interval::Max, gaxi::prost::ConvertError> {
        use crate::model::interval::Max as T;
        match self {
            Self::Maximum(v) => Ok(T::Maximum(v.cnv()?)),
            Self::ExclusiveMaximum(v) => Ok(T::ExclusiveMaximum(v.cnv()?)),
        }
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<Interval> for crate::model::Interval {
    type Output = Interval;
    fn to_proto(self) -> std::result::Result<Interval, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            min: self.min.map(|v| v.to_proto()).transpose()?,
            max: self.max.map(|v| v.to_proto()).transpose()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::FromProto<crate::model::Interval> for Interval {
    fn cnv(self) -> std::result::Result<crate::model::Interval, gaxi::prost::ConvertError> {
        Ok(crate::model::Interval::new()
            .set_min(self.min.map(|v| v.cnv()).transpose()?)
            .set_max(self.max.map(|v| v.cnv()).transpose()?))
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "recommendation-service",
    feature = "search-service",
    feature = "serving-config-service",
    feature = "user-event-service",
))]
impl gaxi::prost::ToProto<UserInfo> for crate::model::UserInfo {
    type Output = UserInfo;
    fn to_proto(self) -> std::result::Result<UserInfo, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            user_id: self.user_id.to_proto()?,
            user_agent: self.user_agent.to_proto()?,
            time_zone: self.time_zone.to_proto()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "recommendation-service",
    feature = "search-service",
    feature = "serving-config-service",
    feature = "user-event-service",
))]
impl gaxi::prost::FromProto<crate::model::UserInfo> for UserInfo {
    fn cnv(self) -> std::result::Result<crate::model::UserInfo, gaxi::prost::ConvertError> {
        Ok(crate::model::UserInfo::new()
            .set_user_id(self.user_id)
            .set_user_agent(self.user_agent)
            .set_time_zone(self.time_zone))
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::ToProto<answer_query_request::safety_spec::safety_setting::HarmBlockThreshold>
    for crate::model::answer_query_request::safety_spec::safety_setting::HarmBlockThreshold
{
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value().ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue("crate::model::answer_query_request::safety_spec::safety_setting::HarmBlockThreshold"))
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::ToProto<answer_query_request::safety_spec::SafetySetting>
    for crate::model::answer_query_request::safety_spec::SafetySetting
{
    type Output = answer_query_request::safety_spec::SafetySetting;
    fn to_proto(
        self,
    ) -> std::result::Result<
        answer_query_request::safety_spec::SafetySetting,
        gaxi::prost::ConvertError,
    > {
        Ok(Self::Output {
            category: self.category.to_proto()?,
            threshold: self.threshold.to_proto()?,
        })
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::FromProto<crate::model::answer_query_request::safety_spec::SafetySetting>
    for answer_query_request::safety_spec::SafetySetting
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::answer_query_request::safety_spec::SafetySetting,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::answer_query_request::safety_spec::SafetySetting::new()
                .set_category(self.category)
                .set_threshold(self.threshold),
        )
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::ToProto<answer_query_request::SafetySpec>
    for crate::model::answer_query_request::SafetySpec
{
    type Output = answer_query_request::SafetySpec;
    fn to_proto(
        self,
    ) -> std::result::Result<answer_query_request::SafetySpec, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            enable: self.enable.to_proto()?,
            safety_settings: self
                .safety_settings
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
        })
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::FromProto<crate::model::answer_query_request::SafetySpec>
    for answer_query_request::SafetySpec
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::answer_query_request::SafetySpec,
        gaxi::prost::ConvertError,
    > {
        Ok(crate::model::answer_query_request::SafetySpec::new()
            .set_enable(self.enable)
            .set_safety_settings(
                self.safety_settings
                    .into_iter()
                    .map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            ))
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::ToProto<answer_query_request::RelatedQuestionsSpec>
    for crate::model::answer_query_request::RelatedQuestionsSpec
{
    type Output = answer_query_request::RelatedQuestionsSpec;
    fn to_proto(
        self,
    ) -> std::result::Result<answer_query_request::RelatedQuestionsSpec, gaxi::prost::ConvertError>
    {
        Ok(Self::Output {
            enable: self.enable.to_proto()?,
        })
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::FromProto<crate::model::answer_query_request::RelatedQuestionsSpec>
    for answer_query_request::RelatedQuestionsSpec
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::answer_query_request::RelatedQuestionsSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(crate::model::answer_query_request::RelatedQuestionsSpec::new().set_enable(self.enable))
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::ToProto<answer_query_request::grounding_spec::FilteringLevel>
    for crate::model::answer_query_request::grounding_spec::FilteringLevel
{
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value()
            .ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue(
                "crate::model::answer_query_request::grounding_spec::FilteringLevel",
            ))
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::ToProto<answer_query_request::GroundingSpec>
    for crate::model::answer_query_request::GroundingSpec
{
    type Output = answer_query_request::GroundingSpec;
    fn to_proto(
        self,
    ) -> std::result::Result<answer_query_request::GroundingSpec, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            include_grounding_supports: self.include_grounding_supports.to_proto()?,
            filtering_level: self.filtering_level.to_proto()?,
        })
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::FromProto<crate::model::answer_query_request::GroundingSpec>
    for answer_query_request::GroundingSpec
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::answer_query_request::GroundingSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(crate::model::answer_query_request::GroundingSpec::new()
            .set_include_grounding_supports(self.include_grounding_supports)
            .set_filtering_level(self.filtering_level))
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::ToProto<answer_query_request::answer_generation_spec::ModelSpec>
    for crate::model::answer_query_request::answer_generation_spec::ModelSpec
{
    type Output = answer_query_request::answer_generation_spec::ModelSpec;
    fn to_proto(
        self,
    ) -> std::result::Result<
        answer_query_request::answer_generation_spec::ModelSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(Self::Output {
            model_version: self.model_version.to_proto()?,
        })
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::FromProto<crate::model::answer_query_request::answer_generation_spec::ModelSpec>
    for answer_query_request::answer_generation_spec::ModelSpec
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::answer_query_request::answer_generation_spec::ModelSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::answer_query_request::answer_generation_spec::ModelSpec::new()
                .set_model_version(self.model_version),
        )
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::ToProto<answer_query_request::answer_generation_spec::PromptSpec>
    for crate::model::answer_query_request::answer_generation_spec::PromptSpec
{
    type Output = answer_query_request::answer_generation_spec::PromptSpec;
    fn to_proto(
        self,
    ) -> std::result::Result<
        answer_query_request::answer_generation_spec::PromptSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(Self::Output {
            preamble: self.preamble.to_proto()?,
        })
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::FromProto<crate::model::answer_query_request::answer_generation_spec::PromptSpec>
    for answer_query_request::answer_generation_spec::PromptSpec
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::answer_query_request::answer_generation_spec::PromptSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::answer_query_request::answer_generation_spec::PromptSpec::new()
                .set_preamble(self.preamble),
        )
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::ToProto<answer_query_request::AnswerGenerationSpec>
    for crate::model::answer_query_request::AnswerGenerationSpec
{
    type Output = answer_query_request::AnswerGenerationSpec;
    fn to_proto(
        self,
    ) -> std::result::Result<answer_query_request::AnswerGenerationSpec, gaxi::prost::ConvertError>
    {
        Ok(Self::Output {
            model_spec: self.model_spec.map(|v| v.to_proto()).transpose()?,
            prompt_spec: self.prompt_spec.map(|v| v.to_proto()).transpose()?,
            include_citations: self.include_citations.to_proto()?,
            answer_language_code: self.answer_language_code.to_proto()?,
            ignore_adversarial_query: self.ignore_adversarial_query.to_proto()?,
            ignore_non_answer_seeking_query: self.ignore_non_answer_seeking_query.to_proto()?,
            ignore_low_relevant_content: self
                .ignore_low_relevant_content
                .map(|v| v.to_proto())
                .transpose()?,
            ignore_jail_breaking_query: self.ignore_jail_breaking_query.to_proto()?,
        })
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::FromProto<crate::model::answer_query_request::AnswerGenerationSpec>
    for answer_query_request::AnswerGenerationSpec
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::answer_query_request::AnswerGenerationSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::answer_query_request::AnswerGenerationSpec::new()
                .set_or_clear_model_spec(self.model_spec.map(|v| v.cnv()).transpose()?)
                .set_or_clear_prompt_spec(self.prompt_spec.map(|v| v.cnv()).transpose()?)
                .set_include_citations(self.include_citations)
                .set_answer_language_code(self.answer_language_code)
                .set_ignore_adversarial_query(self.ignore_adversarial_query)
                .set_ignore_non_answer_seeking_query(self.ignore_non_answer_seeking_query)
                .set_or_clear_ignore_low_relevant_content(
                    self.ignore_low_relevant_content
                        .map(|v| v.cnv())
                        .transpose()?,
                )
                .set_ignore_jail_breaking_query(self.ignore_jail_breaking_query),
        )
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::ToProto<answer_query_request::search_spec::SearchParams>
    for crate::model::answer_query_request::search_spec::SearchParams
{
    type Output = answer_query_request::search_spec::SearchParams;
    fn to_proto(
        self,
    ) -> std::result::Result<
        answer_query_request::search_spec::SearchParams,
        gaxi::prost::ConvertError,
    > {
        Ok(Self::Output {
            max_return_results: self.max_return_results.to_proto()?,
            filter: self.filter.to_proto()?,
            boost_spec: self.boost_spec.map(|v| v.to_proto()).transpose()?,
            order_by: self.order_by.to_proto()?,
            search_result_mode: self.search_result_mode.to_proto()?,
            data_store_specs: self
                .data_store_specs
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
        })
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::FromProto<crate::model::answer_query_request::search_spec::SearchParams>
    for answer_query_request::search_spec::SearchParams
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::answer_query_request::search_spec::SearchParams,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::answer_query_request::search_spec::SearchParams::new()
                .set_max_return_results(self.max_return_results)
                .set_filter(self.filter)
                .set_or_clear_boost_spec(self.boost_spec.map(|v| v.cnv()).transpose()?)
                .set_order_by(self.order_by)
                .set_search_result_mode(self.search_result_mode)
                .set_data_store_specs(
                    self.data_store_specs
                        .into_iter()
                        .map(|v| v.cnv())
                        .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
                ),
        )
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::ToProto<answer_query_request::search_spec::search_result_list::search_result::unstructured_document_info::DocumentContext> for crate::model::answer_query_request::search_spec::search_result_list::search_result::unstructured_document_info::DocumentContext {
    type Output = answer_query_request::search_spec::search_result_list::search_result::unstructured_document_info::DocumentContext;
    fn to_proto(self) -> std::result::Result<answer_query_request::search_spec::search_result_list::search_result::unstructured_document_info::DocumentContext, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            page_identifier: self.page_identifier.to_proto()?,
            content: self.content.to_proto()?,
        })
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::FromProto<crate::model::answer_query_request::search_spec::search_result_list::search_result::unstructured_document_info::DocumentContext> for answer_query_request::search_spec::search_result_list::search_result::unstructured_document_info::DocumentContext {
    fn cnv(self) -> std::result::Result<crate::model::answer_query_request::search_spec::search_result_list::search_result::unstructured_document_info::DocumentContext, gaxi::prost::ConvertError> {
        Ok(
            crate::model::answer_query_request::search_spec::search_result_list::search_result::unstructured_document_info::DocumentContext::new()
                .set_page_identifier(self.page_identifier)
                .set_content(self.content)
        )
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::ToProto<answer_query_request::search_spec::search_result_list::search_result::unstructured_document_info::ExtractiveSegment> for crate::model::answer_query_request::search_spec::search_result_list::search_result::unstructured_document_info::ExtractiveSegment {
    type Output = answer_query_request::search_spec::search_result_list::search_result::unstructured_document_info::ExtractiveSegment;
    fn to_proto(self) -> std::result::Result<answer_query_request::search_spec::search_result_list::search_result::unstructured_document_info::ExtractiveSegment, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            page_identifier: self.page_identifier.to_proto()?,
            content: self.content.to_proto()?,
        })
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::FromProto<crate::model::answer_query_request::search_spec::search_result_list::search_result::unstructured_document_info::ExtractiveSegment> for answer_query_request::search_spec::search_result_list::search_result::unstructured_document_info::ExtractiveSegment {
    fn cnv(self) -> std::result::Result<crate::model::answer_query_request::search_spec::search_result_list::search_result::unstructured_document_info::ExtractiveSegment, gaxi::prost::ConvertError> {
        Ok(
            crate::model::answer_query_request::search_spec::search_result_list::search_result::unstructured_document_info::ExtractiveSegment::new()
                .set_page_identifier(self.page_identifier)
                .set_content(self.content)
        )
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::ToProto<answer_query_request::search_spec::search_result_list::search_result::unstructured_document_info::ExtractiveAnswer> for crate::model::answer_query_request::search_spec::search_result_list::search_result::unstructured_document_info::ExtractiveAnswer {
    type Output = answer_query_request::search_spec::search_result_list::search_result::unstructured_document_info::ExtractiveAnswer;
    fn to_proto(self) -> std::result::Result<answer_query_request::search_spec::search_result_list::search_result::unstructured_document_info::ExtractiveAnswer, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            page_identifier: self.page_identifier.to_proto()?,
            content: self.content.to_proto()?,
        })
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::FromProto<crate::model::answer_query_request::search_spec::search_result_list::search_result::unstructured_document_info::ExtractiveAnswer> for answer_query_request::search_spec::search_result_list::search_result::unstructured_document_info::ExtractiveAnswer {
    fn cnv(self) -> std::result::Result<crate::model::answer_query_request::search_spec::search_result_list::search_result::unstructured_document_info::ExtractiveAnswer, gaxi::prost::ConvertError> {
        Ok(
            crate::model::answer_query_request::search_spec::search_result_list::search_result::unstructured_document_info::ExtractiveAnswer::new()
                .set_page_identifier(self.page_identifier)
                .set_content(self.content)
        )
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::ToProto<answer_query_request::search_spec::search_result_list::search_result::UnstructuredDocumentInfo> for crate::model::answer_query_request::search_spec::search_result_list::search_result::UnstructuredDocumentInfo {
    type Output = answer_query_request::search_spec::search_result_list::search_result::UnstructuredDocumentInfo;
    fn to_proto(self) -> std::result::Result<answer_query_request::search_spec::search_result_list::search_result::UnstructuredDocumentInfo, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            document: self.document.to_proto()?,
            uri: self.uri.to_proto()?,
            title: self.title.to_proto()?,
            document_contexts: self.document_contexts
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            extractive_segments: self.extractive_segments
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            extractive_answers: self.extractive_answers
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
        })
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::FromProto<crate::model::answer_query_request::search_spec::search_result_list::search_result::UnstructuredDocumentInfo> for answer_query_request::search_spec::search_result_list::search_result::UnstructuredDocumentInfo {
    fn cnv(self) -> std::result::Result<crate::model::answer_query_request::search_spec::search_result_list::search_result::UnstructuredDocumentInfo, gaxi::prost::ConvertError> {
        Ok(
            crate::model::answer_query_request::search_spec::search_result_list::search_result::UnstructuredDocumentInfo::new()
                .set_document(self.document)
                .set_uri(self.uri)
                .set_title(self.title)
                .set_document_contexts(self.document_contexts.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
                .set_extractive_segments(self.extractive_segments.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
                .set_extractive_answers(self.extractive_answers.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
        )
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::ToProto<answer_query_request::search_spec::search_result_list::search_result::chunk_info::DocumentMetadata> for crate::model::answer_query_request::search_spec::search_result_list::search_result::chunk_info::DocumentMetadata {
    type Output = answer_query_request::search_spec::search_result_list::search_result::chunk_info::DocumentMetadata;
    fn to_proto(self) -> std::result::Result<answer_query_request::search_spec::search_result_list::search_result::chunk_info::DocumentMetadata, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            uri: self.uri.to_proto()?,
            title: self.title.to_proto()?,
        })
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::FromProto<crate::model::answer_query_request::search_spec::search_result_list::search_result::chunk_info::DocumentMetadata> for answer_query_request::search_spec::search_result_list::search_result::chunk_info::DocumentMetadata {
    fn cnv(self) -> std::result::Result<crate::model::answer_query_request::search_spec::search_result_list::search_result::chunk_info::DocumentMetadata, gaxi::prost::ConvertError> {
        Ok(
            crate::model::answer_query_request::search_spec::search_result_list::search_result::chunk_info::DocumentMetadata::new()
                .set_uri(self.uri)
                .set_title(self.title)
        )
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::ToProto<answer_query_request::search_spec::search_result_list::search_result::ChunkInfo> for crate::model::answer_query_request::search_spec::search_result_list::search_result::ChunkInfo {
    type Output = answer_query_request::search_spec::search_result_list::search_result::ChunkInfo;
    fn to_proto(self) -> std::result::Result<answer_query_request::search_spec::search_result_list::search_result::ChunkInfo, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            chunk: self.chunk.to_proto()?,
            content: self.content.to_proto()?,
            document_metadata: self.document_metadata.map(|v| v.to_proto()).transpose()?,
        })
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::FromProto<crate::model::answer_query_request::search_spec::search_result_list::search_result::ChunkInfo> for answer_query_request::search_spec::search_result_list::search_result::ChunkInfo {
    fn cnv(self) -> std::result::Result<crate::model::answer_query_request::search_spec::search_result_list::search_result::ChunkInfo, gaxi::prost::ConvertError> {
        Ok(
            crate::model::answer_query_request::search_spec::search_result_list::search_result::ChunkInfo::new()
                .set_chunk(self.chunk)
                .set_content(self.content)
                .set_or_clear_document_metadata(self.document_metadata.map(|v| v.cnv()).transpose()?)
        )
    }
}

#[cfg(feature = "conversational-search-service")]
impl
    gaxi::prost::ToProto<
        answer_query_request::search_spec::search_result_list::search_result::Content,
    >
    for crate::model::answer_query_request::search_spec::search_result_list::search_result::Content
{
    type Output = answer_query_request::search_spec::search_result_list::search_result::Content;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        match self {
            Self::UnstructuredDocumentInfo(v) => {
                Ok(Self::Output::UnstructuredDocumentInfo((*v).to_proto()?))
            }
            Self::ChunkInfo(v) => Ok(Self::Output::ChunkInfo((*v).to_proto()?)),
        }
    }
}

#[cfg(feature = "conversational-search-service")]
impl
    gaxi::prost::FromProto<
        crate::model::answer_query_request::search_spec::search_result_list::search_result::Content,
    > for answer_query_request::search_spec::search_result_list::search_result::Content
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::answer_query_request::search_spec::search_result_list::search_result::Content,
        gaxi::prost::ConvertError,
    > {
        use crate::model::answer_query_request::search_spec::search_result_list::search_result::Content as T;
        match self {
            Self::UnstructuredDocumentInfo(v) => {
                Ok(T::UnstructuredDocumentInfo(std::boxed::Box::new(v.cnv()?)))
            }
            Self::ChunkInfo(v) => Ok(T::ChunkInfo(std::boxed::Box::new(v.cnv()?))),
        }
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::ToProto<answer_query_request::search_spec::search_result_list::SearchResult>
    for crate::model::answer_query_request::search_spec::search_result_list::SearchResult
{
    type Output = answer_query_request::search_spec::search_result_list::SearchResult;
    fn to_proto(
        self,
    ) -> std::result::Result<
        answer_query_request::search_spec::search_result_list::SearchResult,
        gaxi::prost::ConvertError,
    > {
        Ok(Self::Output {
            content: self.content.map(|v| v.to_proto()).transpose()?,
        })
    }
}

#[cfg(feature = "conversational-search-service")]
impl
    gaxi::prost::FromProto<
        crate::model::answer_query_request::search_spec::search_result_list::SearchResult,
    > for answer_query_request::search_spec::search_result_list::SearchResult
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::answer_query_request::search_spec::search_result_list::SearchResult,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::answer_query_request::search_spec::search_result_list::SearchResult::new(
            )
            .set_content(self.content.map(|v| v.cnv()).transpose()?),
        )
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::ToProto<answer_query_request::search_spec::SearchResultList>
    for crate::model::answer_query_request::search_spec::SearchResultList
{
    type Output = answer_query_request::search_spec::SearchResultList;
    fn to_proto(
        self,
    ) -> std::result::Result<
        answer_query_request::search_spec::SearchResultList,
        gaxi::prost::ConvertError,
    > {
        Ok(Self::Output {
            search_results: self
                .search_results
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
        })
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::FromProto<crate::model::answer_query_request::search_spec::SearchResultList>
    for answer_query_request::search_spec::SearchResultList
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::answer_query_request::search_spec::SearchResultList,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::answer_query_request::search_spec::SearchResultList::new()
                .set_search_results(
                    self.search_results
                        .into_iter()
                        .map(|v| v.cnv())
                        .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
                ),
        )
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::ToProto<answer_query_request::search_spec::Input>
    for crate::model::answer_query_request::search_spec::Input
{
    type Output = answer_query_request::search_spec::Input;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        match self {
            Self::SearchParams(v) => Ok(Self::Output::SearchParams((*v).to_proto()?)),
            Self::SearchResultList(v) => Ok(Self::Output::SearchResultList((*v).to_proto()?)),
        }
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::FromProto<crate::model::answer_query_request::search_spec::Input>
    for answer_query_request::search_spec::Input
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::answer_query_request::search_spec::Input,
        gaxi::prost::ConvertError,
    > {
        use crate::model::answer_query_request::search_spec::Input as T;
        match self {
            Self::SearchParams(v) => Ok(T::SearchParams(std::boxed::Box::new(v.cnv()?))),
            Self::SearchResultList(v) => Ok(T::SearchResultList(std::boxed::Box::new(v.cnv()?))),
        }
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::ToProto<answer_query_request::SearchSpec>
    for crate::model::answer_query_request::SearchSpec
{
    type Output = answer_query_request::SearchSpec;
    fn to_proto(
        self,
    ) -> std::result::Result<answer_query_request::SearchSpec, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            input: self.input.map(|v| v.to_proto()).transpose()?,
        })
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::FromProto<crate::model::answer_query_request::SearchSpec>
    for answer_query_request::SearchSpec
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::answer_query_request::SearchSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(crate::model::answer_query_request::SearchSpec::new()
            .set_input(self.input.map(|v| v.cnv()).transpose()?))
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::ToProto<answer_query_request::query_understanding_spec::query_classification_spec::Type> for crate::model::answer_query_request::query_understanding_spec::query_classification_spec::Type {
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value().ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue("crate::model::answer_query_request::query_understanding_spec::query_classification_spec::Type"))
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::ToProto<answer_query_request::query_understanding_spec::QueryClassificationSpec>
    for crate::model::answer_query_request::query_understanding_spec::QueryClassificationSpec
{
    type Output = answer_query_request::query_understanding_spec::QueryClassificationSpec;
    fn to_proto(
        self,
    ) -> std::result::Result<
        answer_query_request::query_understanding_spec::QueryClassificationSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(Self::Output {
            types: self
                .types
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
        })
    }
}

#[cfg(feature = "conversational-search-service")]
impl
    gaxi::prost::FromProto<
        crate::model::answer_query_request::query_understanding_spec::QueryClassificationSpec,
    > for answer_query_request::query_understanding_spec::QueryClassificationSpec
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::answer_query_request::query_understanding_spec::QueryClassificationSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::answer_query_request::query_understanding_spec::QueryClassificationSpec::new()
                .set_types(self.types.into_iter().map(crate::model::answer_query_request::query_understanding_spec::query_classification_spec::Type::from))
        )
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::ToProto<answer_query_request::query_understanding_spec::query_rephraser_spec::model_spec::ModelType> for crate::model::answer_query_request::query_understanding_spec::query_rephraser_spec::model_spec::ModelType {
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value().ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue("crate::model::answer_query_request::query_understanding_spec::query_rephraser_spec::model_spec::ModelType"))
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::ToProto<answer_query_request::query_understanding_spec::query_rephraser_spec::ModelSpec> for crate::model::answer_query_request::query_understanding_spec::query_rephraser_spec::ModelSpec {
    type Output = answer_query_request::query_understanding_spec::query_rephraser_spec::ModelSpec;
    fn to_proto(self) -> std::result::Result<answer_query_request::query_understanding_spec::query_rephraser_spec::ModelSpec, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            model_type: self.model_type.to_proto()?,
        })
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::FromProto<crate::model::answer_query_request::query_understanding_spec::query_rephraser_spec::ModelSpec> for answer_query_request::query_understanding_spec::query_rephraser_spec::ModelSpec {
    fn cnv(self) -> std::result::Result<crate::model::answer_query_request::query_understanding_spec::query_rephraser_spec::ModelSpec, gaxi::prost::ConvertError> {
        Ok(
            crate::model::answer_query_request::query_understanding_spec::query_rephraser_spec::ModelSpec::new()
                .set_model_type(self.model_type)
        )
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::ToProto<answer_query_request::query_understanding_spec::QueryRephraserSpec>
    for crate::model::answer_query_request::query_understanding_spec::QueryRephraserSpec
{
    type Output = answer_query_request::query_understanding_spec::QueryRephraserSpec;
    fn to_proto(
        self,
    ) -> std::result::Result<
        answer_query_request::query_understanding_spec::QueryRephraserSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(Self::Output {
            disable: self.disable.to_proto()?,
            max_rephrase_steps: self.max_rephrase_steps.to_proto()?,
            model_spec: self.model_spec.map(|v| v.to_proto()).transpose()?,
        })
    }
}

#[cfg(feature = "conversational-search-service")]
impl
    gaxi::prost::FromProto<
        crate::model::answer_query_request::query_understanding_spec::QueryRephraserSpec,
    > for answer_query_request::query_understanding_spec::QueryRephraserSpec
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::answer_query_request::query_understanding_spec::QueryRephraserSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::answer_query_request::query_understanding_spec::QueryRephraserSpec::new()
                .set_disable(self.disable)
                .set_max_rephrase_steps(self.max_rephrase_steps)
                .set_or_clear_model_spec(self.model_spec.map(|v| v.cnv()).transpose()?),
        )
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::ToProto<answer_query_request::QueryUnderstandingSpec>
    for crate::model::answer_query_request::QueryUnderstandingSpec
{
    type Output = answer_query_request::QueryUnderstandingSpec;
    fn to_proto(
        self,
    ) -> std::result::Result<answer_query_request::QueryUnderstandingSpec, gaxi::prost::ConvertError>
    {
        Ok(Self::Output {
            query_classification_spec: self
                .query_classification_spec
                .map(|v| v.to_proto())
                .transpose()?,
            query_rephraser_spec: self
                .query_rephraser_spec
                .map(|v| v.to_proto())
                .transpose()?,
            disable_spell_correction: self.disable_spell_correction.to_proto()?,
        })
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::FromProto<crate::model::answer_query_request::QueryUnderstandingSpec>
    for answer_query_request::QueryUnderstandingSpec
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::answer_query_request::QueryUnderstandingSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::answer_query_request::QueryUnderstandingSpec::new()
                .set_or_clear_query_classification_spec(
                    self.query_classification_spec
                        .map(|v| v.cnv())
                        .transpose()?,
                )
                .set_or_clear_query_rephraser_spec(
                    self.query_rephraser_spec.map(|v| v.cnv()).transpose()?,
                )
                .set_disable_spell_correction(self.disable_spell_correction),
        )
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::ToProto<answer_query_request::end_user_spec::end_user_meta_data::chunk_info::DocumentMetadata> for crate::model::answer_query_request::end_user_spec::end_user_meta_data::chunk_info::DocumentMetadata {
    type Output = answer_query_request::end_user_spec::end_user_meta_data::chunk_info::DocumentMetadata;
    fn to_proto(self) -> std::result::Result<answer_query_request::end_user_spec::end_user_meta_data::chunk_info::DocumentMetadata, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            title: self.title.to_proto()?,
        })
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::FromProto<crate::model::answer_query_request::end_user_spec::end_user_meta_data::chunk_info::DocumentMetadata> for answer_query_request::end_user_spec::end_user_meta_data::chunk_info::DocumentMetadata {
    fn cnv(self) -> std::result::Result<crate::model::answer_query_request::end_user_spec::end_user_meta_data::chunk_info::DocumentMetadata, gaxi::prost::ConvertError> {
        Ok(
            crate::model::answer_query_request::end_user_spec::end_user_meta_data::chunk_info::DocumentMetadata::new()
                .set_title(self.title)
        )
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::ToProto<answer_query_request::end_user_spec::end_user_meta_data::ChunkInfo>
    for crate::model::answer_query_request::end_user_spec::end_user_meta_data::ChunkInfo
{
    type Output = answer_query_request::end_user_spec::end_user_meta_data::ChunkInfo;
    fn to_proto(
        self,
    ) -> std::result::Result<
        answer_query_request::end_user_spec::end_user_meta_data::ChunkInfo,
        gaxi::prost::ConvertError,
    > {
        Ok(Self::Output {
            content: self.content.to_proto()?,
            document_metadata: self.document_metadata.map(|v| v.to_proto()).transpose()?,
        })
    }
}

#[cfg(feature = "conversational-search-service")]
impl
    gaxi::prost::FromProto<
        crate::model::answer_query_request::end_user_spec::end_user_meta_data::ChunkInfo,
    > for answer_query_request::end_user_spec::end_user_meta_data::ChunkInfo
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::answer_query_request::end_user_spec::end_user_meta_data::ChunkInfo,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::answer_query_request::end_user_spec::end_user_meta_data::ChunkInfo::new()
                .set_content(self.content)
                .set_or_clear_document_metadata(
                    self.document_metadata.map(|v| v.cnv()).transpose()?,
                ),
        )
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::ToProto<answer_query_request::end_user_spec::end_user_meta_data::Content>
    for crate::model::answer_query_request::end_user_spec::end_user_meta_data::Content
{
    type Output = answer_query_request::end_user_spec::end_user_meta_data::Content;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        match self {
            Self::ChunkInfo(v) => Ok(Self::Output::ChunkInfo((*v).to_proto()?)),
        }
    }
}

#[cfg(feature = "conversational-search-service")]
impl
    gaxi::prost::FromProto<
        crate::model::answer_query_request::end_user_spec::end_user_meta_data::Content,
    > for answer_query_request::end_user_spec::end_user_meta_data::Content
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::answer_query_request::end_user_spec::end_user_meta_data::Content,
        gaxi::prost::ConvertError,
    > {
        use crate::model::answer_query_request::end_user_spec::end_user_meta_data::Content as T;
        match self {
            Self::ChunkInfo(v) => Ok(T::ChunkInfo(std::boxed::Box::new(v.cnv()?))),
        }
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::ToProto<answer_query_request::end_user_spec::EndUserMetaData>
    for crate::model::answer_query_request::end_user_spec::EndUserMetaData
{
    type Output = answer_query_request::end_user_spec::EndUserMetaData;
    fn to_proto(
        self,
    ) -> std::result::Result<
        answer_query_request::end_user_spec::EndUserMetaData,
        gaxi::prost::ConvertError,
    > {
        Ok(Self::Output {
            content: self.content.map(|v| v.to_proto()).transpose()?,
        })
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::FromProto<crate::model::answer_query_request::end_user_spec::EndUserMetaData>
    for answer_query_request::end_user_spec::EndUserMetaData
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::answer_query_request::end_user_spec::EndUserMetaData,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::answer_query_request::end_user_spec::EndUserMetaData::new()
                .set_content(self.content.map(|v| v.cnv()).transpose()?),
        )
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::ToProto<answer_query_request::EndUserSpec>
    for crate::model::answer_query_request::EndUserSpec
{
    type Output = answer_query_request::EndUserSpec;
    fn to_proto(
        self,
    ) -> std::result::Result<answer_query_request::EndUserSpec, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            end_user_metadata: self
                .end_user_metadata
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
        })
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::FromProto<crate::model::answer_query_request::EndUserSpec>
    for answer_query_request::EndUserSpec
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::answer_query_request::EndUserSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::answer_query_request::EndUserSpec::new().set_end_user_metadata(
                self.end_user_metadata
                    .into_iter()
                    .map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            ),
        )
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::ToProto<AnswerQueryRequest> for crate::model::AnswerQueryRequest {
    type Output = AnswerQueryRequest;
    fn to_proto(self) -> std::result::Result<AnswerQueryRequest, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            serving_config: self.serving_config.to_proto()?,
            query: self.query.map(|v| v.to_proto()).transpose()?,
            session: self.session.to_proto()?,
            safety_spec: self.safety_spec.map(|v| v.to_proto()).transpose()?,
            related_questions_spec: self
                .related_questions_spec
                .map(|v| v.to_proto())
                .transpose()?,
            grounding_spec: self.grounding_spec.map(|v| v.to_proto()).transpose()?,
            answer_generation_spec: self
                .answer_generation_spec
                .map(|v| v.to_proto())
                .transpose()?,
            search_spec: self.search_spec.map(|v| v.to_proto()).transpose()?,
            query_understanding_spec: self
                .query_understanding_spec
                .map(|v| v.to_proto())
                .transpose()?,
            asynchronous_mode: self.asynchronous_mode.to_proto()?,
            user_pseudo_id: self.user_pseudo_id.to_proto()?,
            user_labels: self
                .user_labels
                .into_iter()
                .map(|(k, v)| gaxi::prost::pair_transpose(k.to_proto(), v.to_proto()))
                .collect::<std::result::Result<std::collections::HashMap<_, _>, _>>()?,
            end_user_spec: self.end_user_spec.map(|v| v.to_proto()).transpose()?,
        })
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::FromProto<crate::model::AnswerQueryRequest> for AnswerQueryRequest {
    fn cnv(
        self,
    ) -> std::result::Result<crate::model::AnswerQueryRequest, gaxi::prost::ConvertError> {
        Ok(crate::model::AnswerQueryRequest::new()
            .set_serving_config(self.serving_config)
            .set_or_clear_query(self.query.map(|v| v.cnv()).transpose()?)
            .set_session(self.session)
            .set_or_clear_safety_spec(self.safety_spec.map(|v| v.cnv()).transpose()?)
            .set_or_clear_related_questions_spec(
                self.related_questions_spec.map(|v| v.cnv()).transpose()?,
            )
            .set_or_clear_grounding_spec(self.grounding_spec.map(|v| v.cnv()).transpose()?)
            .set_or_clear_answer_generation_spec(
                self.answer_generation_spec.map(|v| v.cnv()).transpose()?,
            )
            .set_or_clear_search_spec(self.search_spec.map(|v| v.cnv()).transpose()?)
            .set_or_clear_query_understanding_spec(
                self.query_understanding_spec.map(|v| v.cnv()).transpose()?,
            )
            .set_asynchronous_mode(self.asynchronous_mode)
            .set_user_pseudo_id(self.user_pseudo_id)
            .set_user_labels(
                self.user_labels
                    .into_iter()
                    .map(|(k, v)| gaxi::prost::pair_transpose(k.cnv(), v.cnv()))
                    .collect::<std::result::Result<std::collections::HashMap<_, _>, _>>()?,
            )
            .set_or_clear_end_user_spec(self.end_user_spec.map(|v| v.cnv()).transpose()?))
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::ToProto<AnswerQueryResponse> for crate::model::AnswerQueryResponse {
    type Output = AnswerQueryResponse;
    fn to_proto(self) -> std::result::Result<AnswerQueryResponse, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            answer: self.answer.map(|v| v.to_proto()).transpose()?,
            session: self.session.map(|v| v.to_proto()).transpose()?,
            answer_query_token: self.answer_query_token.to_proto()?,
        })
    }
}

#[cfg(feature = "conversational-search-service")]
impl gaxi::prost::FromProto<crate::model::AnswerQueryResponse> for AnswerQueryResponse {
    fn cnv(
        self,
    ) -> std::result::Result<crate::model::AnswerQueryResponse, gaxi::prost::ConvertError> {
        Ok(crate::model::AnswerQueryResponse::new()
            .set_or_clear_answer(self.answer.map(|v| v.cnv()).transpose()?)
            .set_or_clear_session(self.session.map(|v| v.cnv()).transpose()?)
            .set_answer_query_token(self.answer_query_token))
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::ToProto<grounded_generation_content::part::Data>
    for crate::model::grounded_generation_content::part::Data
{
    type Output = grounded_generation_content::part::Data;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        match self {
            Self::Text(v) => Ok(Self::Output::Text(v.to_proto()?)),
        }
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::FromProto<crate::model::grounded_generation_content::part::Data>
    for grounded_generation_content::part::Data
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::grounded_generation_content::part::Data,
        gaxi::prost::ConvertError,
    > {
        use crate::model::grounded_generation_content::part::Data as T;
        match self {
            Self::Text(v) => Ok(T::Text(v.cnv()?)),
        }
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::ToProto<grounded_generation_content::Part>
    for crate::model::grounded_generation_content::Part
{
    type Output = grounded_generation_content::Part;
    fn to_proto(
        self,
    ) -> std::result::Result<grounded_generation_content::Part, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            data: self.data.map(|v| v.to_proto()).transpose()?,
        })
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::FromProto<crate::model::grounded_generation_content::Part>
    for grounded_generation_content::Part
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::grounded_generation_content::Part,
        gaxi::prost::ConvertError,
    > {
        Ok(crate::model::grounded_generation_content::Part::new()
            .set_data(self.data.map(|v| v.cnv()).transpose()?))
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::ToProto<GroundedGenerationContent> for crate::model::GroundedGenerationContent {
    type Output = GroundedGenerationContent;
    fn to_proto(self) -> std::result::Result<GroundedGenerationContent, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            role: self.role.to_proto()?,
            parts: self
                .parts
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
        })
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::FromProto<crate::model::GroundedGenerationContent> for GroundedGenerationContent {
    fn cnv(
        self,
    ) -> std::result::Result<crate::model::GroundedGenerationContent, gaxi::prost::ConvertError>
    {
        Ok(crate::model::GroundedGenerationContent::new()
            .set_role(self.role)
            .set_parts(
                self.parts
                    .into_iter()
                    .map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            ))
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::ToProto<generate_grounded_content_request::GenerationSpec>
    for crate::model::generate_grounded_content_request::GenerationSpec
{
    type Output = generate_grounded_content_request::GenerationSpec;
    fn to_proto(
        self,
    ) -> std::result::Result<
        generate_grounded_content_request::GenerationSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(Self::Output {
            model_id: self.model_id.to_proto()?,
            language_code: self.language_code.to_proto()?,
            temperature: self.temperature.map(|v| v.to_proto()).transpose()?,
            top_p: self.top_p.map(|v| v.to_proto()).transpose()?,
            top_k: self.top_k.map(|v| v.to_proto()).transpose()?,
            frequency_penalty: self.frequency_penalty.map(|v| v.to_proto()).transpose()?,
            seed: self.seed.map(|v| v.to_proto()).transpose()?,
            presence_penalty: self.presence_penalty.map(|v| v.to_proto()).transpose()?,
            max_output_tokens: self.max_output_tokens.map(|v| v.to_proto()).transpose()?,
        })
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::FromProto<crate::model::generate_grounded_content_request::GenerationSpec>
    for generate_grounded_content_request::GenerationSpec
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::generate_grounded_content_request::GenerationSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::generate_grounded_content_request::GenerationSpec::new()
                .set_model_id(self.model_id)
                .set_language_code(self.language_code)
                .set_or_clear_temperature(self.temperature.map(|v| v.cnv()).transpose()?)
                .set_or_clear_top_p(self.top_p.map(|v| v.cnv()).transpose()?)
                .set_or_clear_top_k(self.top_k.map(|v| v.cnv()).transpose()?)
                .set_or_clear_frequency_penalty(
                    self.frequency_penalty.map(|v| v.cnv()).transpose()?,
                )
                .set_or_clear_seed(self.seed.map(|v| v.cnv()).transpose()?)
                .set_or_clear_presence_penalty(self.presence_penalty.map(|v| v.cnv()).transpose()?)
                .set_or_clear_max_output_tokens(
                    self.max_output_tokens.map(|v| v.cnv()).transpose()?,
                ),
        )
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::ToProto<generate_grounded_content_request::dynamic_retrieval_configuration::dynamic_retrieval_predictor::Version> for crate::model::generate_grounded_content_request::dynamic_retrieval_configuration::dynamic_retrieval_predictor::Version {
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value().ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue("crate::model::generate_grounded_content_request::dynamic_retrieval_configuration::dynamic_retrieval_predictor::Version"))
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::ToProto<generate_grounded_content_request::dynamic_retrieval_configuration::DynamicRetrievalPredictor> for crate::model::generate_grounded_content_request::dynamic_retrieval_configuration::DynamicRetrievalPredictor {
    type Output = generate_grounded_content_request::dynamic_retrieval_configuration::DynamicRetrievalPredictor;
    fn to_proto(self) -> std::result::Result<generate_grounded_content_request::dynamic_retrieval_configuration::DynamicRetrievalPredictor, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            version: self.version.to_proto()?,
            threshold: self.threshold.map(|v| v.to_proto()).transpose()?,
        })
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::FromProto<crate::model::generate_grounded_content_request::dynamic_retrieval_configuration::DynamicRetrievalPredictor> for generate_grounded_content_request::dynamic_retrieval_configuration::DynamicRetrievalPredictor {
    fn cnv(self) -> std::result::Result<crate::model::generate_grounded_content_request::dynamic_retrieval_configuration::DynamicRetrievalPredictor, gaxi::prost::ConvertError> {
        Ok(
            crate::model::generate_grounded_content_request::dynamic_retrieval_configuration::DynamicRetrievalPredictor::new()
                .set_version(self.version)
                .set_or_clear_threshold(self.threshold.map(|v| v.cnv()).transpose()?)
        )
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::ToProto<generate_grounded_content_request::DynamicRetrievalConfiguration>
    for crate::model::generate_grounded_content_request::DynamicRetrievalConfiguration
{
    type Output = generate_grounded_content_request::DynamicRetrievalConfiguration;
    fn to_proto(
        self,
    ) -> std::result::Result<
        generate_grounded_content_request::DynamicRetrievalConfiguration,
        gaxi::prost::ConvertError,
    > {
        Ok(Self::Output {
            predictor: self.predictor.map(|v| v.to_proto()).transpose()?,
        })
    }
}

#[cfg(feature = "grounded-generation-service")]
impl
    gaxi::prost::FromProto<
        crate::model::generate_grounded_content_request::DynamicRetrievalConfiguration,
    > for generate_grounded_content_request::DynamicRetrievalConfiguration
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::generate_grounded_content_request::DynamicRetrievalConfiguration,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::generate_grounded_content_request::DynamicRetrievalConfiguration::new()
                .set_or_clear_predictor(self.predictor.map(|v| v.cnv()).transpose()?),
        )
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::ToProto<generate_grounded_content_request::grounding_source::InlineSource>
    for crate::model::generate_grounded_content_request::grounding_source::InlineSource
{
    type Output = generate_grounded_content_request::grounding_source::InlineSource;
    fn to_proto(
        self,
    ) -> std::result::Result<
        generate_grounded_content_request::grounding_source::InlineSource,
        gaxi::prost::ConvertError,
    > {
        Ok(Self::Output {
            grounding_facts: self
                .grounding_facts
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            attributes: self
                .attributes
                .into_iter()
                .map(|(k, v)| gaxi::prost::pair_transpose(k.to_proto(), v.to_proto()))
                .collect::<std::result::Result<std::collections::HashMap<_, _>, _>>()?,
        })
    }
}

#[cfg(feature = "grounded-generation-service")]
impl
    gaxi::prost::FromProto<
        crate::model::generate_grounded_content_request::grounding_source::InlineSource,
    > for generate_grounded_content_request::grounding_source::InlineSource
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::generate_grounded_content_request::grounding_source::InlineSource,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::generate_grounded_content_request::grounding_source::InlineSource::new()
                .set_grounding_facts(
                    self.grounding_facts
                        .into_iter()
                        .map(|v| v.cnv())
                        .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
                )
                .set_attributes(
                    self.attributes
                        .into_iter()
                        .map(|(k, v)| gaxi::prost::pair_transpose(k.cnv(), v.cnv()))
                        .collect::<std::result::Result<std::collections::HashMap<_, _>, _>>()?,
                ),
        )
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::ToProto<generate_grounded_content_request::grounding_source::SearchSource>
    for crate::model::generate_grounded_content_request::grounding_source::SearchSource
{
    type Output = generate_grounded_content_request::grounding_source::SearchSource;
    fn to_proto(
        self,
    ) -> std::result::Result<
        generate_grounded_content_request::grounding_source::SearchSource,
        gaxi::prost::ConvertError,
    > {
        Ok(Self::Output {
            serving_config: self.serving_config.to_proto()?,
            max_result_count: self.max_result_count.to_proto()?,
            filter: self.filter.to_proto()?,
            safe_search: self.safe_search.to_proto()?,
        })
    }
}

#[cfg(feature = "grounded-generation-service")]
impl
    gaxi::prost::FromProto<
        crate::model::generate_grounded_content_request::grounding_source::SearchSource,
    > for generate_grounded_content_request::grounding_source::SearchSource
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::generate_grounded_content_request::grounding_source::SearchSource,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::generate_grounded_content_request::grounding_source::SearchSource::new()
                .set_serving_config(self.serving_config)
                .set_max_result_count(self.max_result_count)
                .set_filter(self.filter)
                .set_safe_search(self.safe_search),
        )
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::ToProto<generate_grounded_content_request::grounding_source::GoogleSearchSource>
    for crate::model::generate_grounded_content_request::grounding_source::GoogleSearchSource
{
    type Output = generate_grounded_content_request::grounding_source::GoogleSearchSource;
    fn to_proto(
        self,
    ) -> std::result::Result<
        generate_grounded_content_request::grounding_source::GoogleSearchSource,
        gaxi::prost::ConvertError,
    > {
        Ok(Self::Output {
            dynamic_retrieval_config: self
                .dynamic_retrieval_config
                .map(|v| v.to_proto())
                .transpose()?,
        })
    }
}

#[cfg(feature = "grounded-generation-service")]
impl
    gaxi::prost::FromProto<
        crate::model::generate_grounded_content_request::grounding_source::GoogleSearchSource,
    > for generate_grounded_content_request::grounding_source::GoogleSearchSource
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::generate_grounded_content_request::grounding_source::GoogleSearchSource,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::generate_grounded_content_request::grounding_source::GoogleSearchSource::new()
                .set_or_clear_dynamic_retrieval_config(self.dynamic_retrieval_config.map(|v| v.cnv()).transpose()?)
        )
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::ToProto<generate_grounded_content_request::grounding_source::EnterpriseWebRetrievalSource> for crate::model::generate_grounded_content_request::grounding_source::EnterpriseWebRetrievalSource {
    type Output = generate_grounded_content_request::grounding_source::EnterpriseWebRetrievalSource;
    fn to_proto(self) -> std::result::Result<generate_grounded_content_request::grounding_source::EnterpriseWebRetrievalSource, gaxi::prost::ConvertError> {
        Ok(Self::Output {
        })
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::FromProto<crate::model::generate_grounded_content_request::grounding_source::EnterpriseWebRetrievalSource> for generate_grounded_content_request::grounding_source::EnterpriseWebRetrievalSource {
    fn cnv(self) -> std::result::Result<crate::model::generate_grounded_content_request::grounding_source::EnterpriseWebRetrievalSource, gaxi::prost::ConvertError> {
        Ok(
            crate::model::generate_grounded_content_request::grounding_source::EnterpriseWebRetrievalSource::new()
        )
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::ToProto<generate_grounded_content_request::grounding_source::Source>
    for crate::model::generate_grounded_content_request::grounding_source::Source
{
    type Output = generate_grounded_content_request::grounding_source::Source;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        match self {
            Self::InlineSource(v) => Ok(Self::Output::InlineSource((*v).to_proto()?)),
            Self::SearchSource(v) => Ok(Self::Output::SearchSource((*v).to_proto()?)),
            Self::GoogleSearchSource(v) => Ok(Self::Output::GoogleSearchSource((*v).to_proto()?)),
            Self::EnterpriseWebRetrievalSource(v) => {
                Ok(Self::Output::EnterpriseWebRetrievalSource((*v).to_proto()?))
            }
        }
    }
}

#[cfg(feature = "grounded-generation-service")]
impl
    gaxi::prost::FromProto<
        crate::model::generate_grounded_content_request::grounding_source::Source,
    > for generate_grounded_content_request::grounding_source::Source
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::generate_grounded_content_request::grounding_source::Source,
        gaxi::prost::ConvertError,
    > {
        use crate::model::generate_grounded_content_request::grounding_source::Source as T;
        match self {
            Self::InlineSource(v) => Ok(T::InlineSource(std::boxed::Box::new(v.cnv()?))),
            Self::SearchSource(v) => Ok(T::SearchSource(std::boxed::Box::new(v.cnv()?))),
            Self::GoogleSearchSource(v) => {
                Ok(T::GoogleSearchSource(std::boxed::Box::new(v.cnv()?)))
            }
            Self::EnterpriseWebRetrievalSource(v) => Ok(T::EnterpriseWebRetrievalSource(
                std::boxed::Box::new(v.cnv()?),
            )),
        }
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::ToProto<generate_grounded_content_request::GroundingSource>
    for crate::model::generate_grounded_content_request::GroundingSource
{
    type Output = generate_grounded_content_request::GroundingSource;
    fn to_proto(
        self,
    ) -> std::result::Result<
        generate_grounded_content_request::GroundingSource,
        gaxi::prost::ConvertError,
    > {
        Ok(Self::Output {
            source: self.source.map(|v| v.to_proto()).transpose()?,
        })
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::FromProto<crate::model::generate_grounded_content_request::GroundingSource>
    for generate_grounded_content_request::GroundingSource
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::generate_grounded_content_request::GroundingSource,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::generate_grounded_content_request::GroundingSource::new()
                .set_source(self.source.map(|v| v.cnv()).transpose()?),
        )
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::ToProto<generate_grounded_content_request::GroundingSpec>
    for crate::model::generate_grounded_content_request::GroundingSpec
{
    type Output = generate_grounded_content_request::GroundingSpec;
    fn to_proto(
        self,
    ) -> std::result::Result<
        generate_grounded_content_request::GroundingSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(Self::Output {
            grounding_sources: self
                .grounding_sources
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
        })
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::FromProto<crate::model::generate_grounded_content_request::GroundingSpec>
    for generate_grounded_content_request::GroundingSpec
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::generate_grounded_content_request::GroundingSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::generate_grounded_content_request::GroundingSpec::new()
                .set_grounding_sources(
                    self.grounding_sources
                        .into_iter()
                        .map(|v| v.cnv())
                        .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
                ),
        )
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::ToProto<GenerateGroundedContentRequest>
    for crate::model::GenerateGroundedContentRequest
{
    type Output = GenerateGroundedContentRequest;
    fn to_proto(
        self,
    ) -> std::result::Result<GenerateGroundedContentRequest, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            location: self.location.to_proto()?,
            system_instruction: self.system_instruction.map(|v| v.to_proto()).transpose()?,
            contents: self
                .contents
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            generation_spec: self.generation_spec.map(|v| v.to_proto()).transpose()?,
            grounding_spec: self.grounding_spec.map(|v| v.to_proto()).transpose()?,
            user_labels: self
                .user_labels
                .into_iter()
                .map(|(k, v)| gaxi::prost::pair_transpose(k.to_proto(), v.to_proto()))
                .collect::<std::result::Result<std::collections::HashMap<_, _>, _>>()?,
        })
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::FromProto<crate::model::GenerateGroundedContentRequest>
    for GenerateGroundedContentRequest
{
    fn cnv(
        self,
    ) -> std::result::Result<crate::model::GenerateGroundedContentRequest, gaxi::prost::ConvertError>
    {
        Ok(crate::model::GenerateGroundedContentRequest::new()
            .set_location(self.location)
            .set_or_clear_system_instruction(self.system_instruction.map(|v| v.cnv()).transpose()?)
            .set_contents(
                self.contents
                    .into_iter()
                    .map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            )
            .set_or_clear_generation_spec(self.generation_spec.map(|v| v.cnv()).transpose()?)
            .set_or_clear_grounding_spec(self.grounding_spec.map(|v| v.cnv()).transpose()?)
            .set_user_labels(
                self.user_labels
                    .into_iter()
                    .map(|(k, v)| gaxi::prost::pair_transpose(k.cnv(), v.cnv()))
                    .collect::<std::result::Result<std::collections::HashMap<_, _>, _>>()?,
            ))
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::ToProto<generate_grounded_content_response::candidate::grounding_metadata::retrieval_metadata::Source> for crate::model::generate_grounded_content_response::candidate::grounding_metadata::retrieval_metadata::Source {
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value().ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue("crate::model::generate_grounded_content_response::candidate::grounding_metadata::retrieval_metadata::Source"))
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::ToProto<generate_grounded_content_response::candidate::grounding_metadata::RetrievalMetadata> for crate::model::generate_grounded_content_response::candidate::grounding_metadata::RetrievalMetadata {
    type Output = generate_grounded_content_response::candidate::grounding_metadata::RetrievalMetadata;
    fn to_proto(self) -> std::result::Result<generate_grounded_content_response::candidate::grounding_metadata::RetrievalMetadata, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            source: self.source.to_proto()?,
            dynamic_retrieval_metadata: self.dynamic_retrieval_metadata.map(|v| v.to_proto()).transpose()?,
        })
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::FromProto<crate::model::generate_grounded_content_response::candidate::grounding_metadata::RetrievalMetadata> for generate_grounded_content_response::candidate::grounding_metadata::RetrievalMetadata {
    fn cnv(self) -> std::result::Result<crate::model::generate_grounded_content_response::candidate::grounding_metadata::RetrievalMetadata, gaxi::prost::ConvertError> {
        Ok(
            crate::model::generate_grounded_content_response::candidate::grounding_metadata::RetrievalMetadata::new()
                .set_source(self.source)
                .set_or_clear_dynamic_retrieval_metadata(self.dynamic_retrieval_metadata.map(|v| v.cnv()).transpose()?)
        )
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::ToProto<generate_grounded_content_response::candidate::grounding_metadata::DynamicRetrievalMetadata> for crate::model::generate_grounded_content_response::candidate::grounding_metadata::DynamicRetrievalMetadata {
    type Output = generate_grounded_content_response::candidate::grounding_metadata::DynamicRetrievalMetadata;
    fn to_proto(self) -> std::result::Result<generate_grounded_content_response::candidate::grounding_metadata::DynamicRetrievalMetadata, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            predictor_metadata: self.predictor_metadata.map(|v| v.to_proto()).transpose()?,
        })
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::FromProto<crate::model::generate_grounded_content_response::candidate::grounding_metadata::DynamicRetrievalMetadata> for generate_grounded_content_response::candidate::grounding_metadata::DynamicRetrievalMetadata {
    fn cnv(self) -> std::result::Result<crate::model::generate_grounded_content_response::candidate::grounding_metadata::DynamicRetrievalMetadata, gaxi::prost::ConvertError> {
        Ok(
            crate::model::generate_grounded_content_response::candidate::grounding_metadata::DynamicRetrievalMetadata::new()
                .set_or_clear_predictor_metadata(self.predictor_metadata.map(|v| v.cnv()).transpose()?)
        )
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::ToProto<generate_grounded_content_response::candidate::grounding_metadata::dynamic_retrieval_predictor_metadata::Version> for crate::model::generate_grounded_content_response::candidate::grounding_metadata::dynamic_retrieval_predictor_metadata::Version {
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value().ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue("crate::model::generate_grounded_content_response::candidate::grounding_metadata::dynamic_retrieval_predictor_metadata::Version"))
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::ToProto<generate_grounded_content_response::candidate::grounding_metadata::DynamicRetrievalPredictorMetadata> for crate::model::generate_grounded_content_response::candidate::grounding_metadata::DynamicRetrievalPredictorMetadata {
    type Output = generate_grounded_content_response::candidate::grounding_metadata::DynamicRetrievalPredictorMetadata;
    fn to_proto(self) -> std::result::Result<generate_grounded_content_response::candidate::grounding_metadata::DynamicRetrievalPredictorMetadata, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            version: self.version.to_proto()?,
            prediction: self.prediction.map(|v| v.to_proto()).transpose()?,
        })
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::FromProto<crate::model::generate_grounded_content_response::candidate::grounding_metadata::DynamicRetrievalPredictorMetadata> for generate_grounded_content_response::candidate::grounding_metadata::DynamicRetrievalPredictorMetadata {
    fn cnv(self) -> std::result::Result<crate::model::generate_grounded_content_response::candidate::grounding_metadata::DynamicRetrievalPredictorMetadata, gaxi::prost::ConvertError> {
        Ok(
            crate::model::generate_grounded_content_response::candidate::grounding_metadata::DynamicRetrievalPredictorMetadata::new()
                .set_version(self.version)
                .set_or_clear_prediction(self.prediction.map(|v| v.cnv()).transpose()?)
        )
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::ToProto<generate_grounded_content_response::candidate::grounding_metadata::SearchEntryPoint> for crate::model::generate_grounded_content_response::candidate::grounding_metadata::SearchEntryPoint {
    type Output = generate_grounded_content_response::candidate::grounding_metadata::SearchEntryPoint;
    fn to_proto(self) -> std::result::Result<generate_grounded_content_response::candidate::grounding_metadata::SearchEntryPoint, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            rendered_content: self.rendered_content.to_proto()?,
            sdk_blob: self.sdk_blob.to_proto()?,
        })
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::FromProto<crate::model::generate_grounded_content_response::candidate::grounding_metadata::SearchEntryPoint> for generate_grounded_content_response::candidate::grounding_metadata::SearchEntryPoint {
    fn cnv(self) -> std::result::Result<crate::model::generate_grounded_content_response::candidate::grounding_metadata::SearchEntryPoint, gaxi::prost::ConvertError> {
        Ok(
            crate::model::generate_grounded_content_response::candidate::grounding_metadata::SearchEntryPoint::new()
                .set_rendered_content(self.rendered_content)
                .set_sdk_blob(self.sdk_blob)
        )
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::ToProto<generate_grounded_content_response::candidate::grounding_metadata::GroundingSupport> for crate::model::generate_grounded_content_response::candidate::grounding_metadata::GroundingSupport {
    type Output = generate_grounded_content_response::candidate::grounding_metadata::GroundingSupport;
    fn to_proto(self) -> std::result::Result<generate_grounded_content_response::candidate::grounding_metadata::GroundingSupport, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            claim_text: self.claim_text.to_proto()?,
            support_chunk_indices: self.support_chunk_indices
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            support_score: self.support_score.map(|v| v.to_proto()).transpose()?,
        })
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::FromProto<crate::model::generate_grounded_content_response::candidate::grounding_metadata::GroundingSupport> for generate_grounded_content_response::candidate::grounding_metadata::GroundingSupport {
    fn cnv(self) -> std::result::Result<crate::model::generate_grounded_content_response::candidate::grounding_metadata::GroundingSupport, gaxi::prost::ConvertError> {
        Ok(
            crate::model::generate_grounded_content_response::candidate::grounding_metadata::GroundingSupport::new()
                .set_claim_text(self.claim_text)
                .set_support_chunk_indices(self.support_chunk_indices.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
                .set_or_clear_support_score(self.support_score.map(|v| v.cnv()).transpose()?)
        )
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::ToProto<generate_grounded_content_response::candidate::grounding_metadata::image_metadata::WebsiteInfo> for crate::model::generate_grounded_content_response::candidate::grounding_metadata::image_metadata::WebsiteInfo {
    type Output = generate_grounded_content_response::candidate::grounding_metadata::image_metadata::WebsiteInfo;
    fn to_proto(self) -> std::result::Result<generate_grounded_content_response::candidate::grounding_metadata::image_metadata::WebsiteInfo, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            uri: self.uri.to_proto()?,
            title: self.title.to_proto()?,
        })
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::FromProto<crate::model::generate_grounded_content_response::candidate::grounding_metadata::image_metadata::WebsiteInfo> for generate_grounded_content_response::candidate::grounding_metadata::image_metadata::WebsiteInfo {
    fn cnv(self) -> std::result::Result<crate::model::generate_grounded_content_response::candidate::grounding_metadata::image_metadata::WebsiteInfo, gaxi::prost::ConvertError> {
        Ok(
            crate::model::generate_grounded_content_response::candidate::grounding_metadata::image_metadata::WebsiteInfo::new()
                .set_uri(self.uri)
                .set_title(self.title)
        )
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::ToProto<generate_grounded_content_response::candidate::grounding_metadata::image_metadata::Image> for crate::model::generate_grounded_content_response::candidate::grounding_metadata::image_metadata::Image {
    type Output = generate_grounded_content_response::candidate::grounding_metadata::image_metadata::Image;
    fn to_proto(self) -> std::result::Result<generate_grounded_content_response::candidate::grounding_metadata::image_metadata::Image, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            uri: self.uri.to_proto()?,
            width: self.width.to_proto()?,
            height: self.height.to_proto()?,
        })
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::FromProto<crate::model::generate_grounded_content_response::candidate::grounding_metadata::image_metadata::Image> for generate_grounded_content_response::candidate::grounding_metadata::image_metadata::Image {
    fn cnv(self) -> std::result::Result<crate::model::generate_grounded_content_response::candidate::grounding_metadata::image_metadata::Image, gaxi::prost::ConvertError> {
        Ok(
            crate::model::generate_grounded_content_response::candidate::grounding_metadata::image_metadata::Image::new()
                .set_uri(self.uri)
                .set_width(self.width)
                .set_height(self.height)
        )
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::ToProto<generate_grounded_content_response::candidate::grounding_metadata::ImageMetadata> for crate::model::generate_grounded_content_response::candidate::grounding_metadata::ImageMetadata {
    type Output = generate_grounded_content_response::candidate::grounding_metadata::ImageMetadata;
    fn to_proto(self) -> std::result::Result<generate_grounded_content_response::candidate::grounding_metadata::ImageMetadata, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            image: self.image.map(|v| v.to_proto()).transpose()?,
            thumbnail: self.thumbnail.map(|v| v.to_proto()).transpose()?,
            source: self.source.map(|v| v.to_proto()).transpose()?,
        })
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::FromProto<crate::model::generate_grounded_content_response::candidate::grounding_metadata::ImageMetadata> for generate_grounded_content_response::candidate::grounding_metadata::ImageMetadata {
    fn cnv(self) -> std::result::Result<crate::model::generate_grounded_content_response::candidate::grounding_metadata::ImageMetadata, gaxi::prost::ConvertError> {
        Ok(
            crate::model::generate_grounded_content_response::candidate::grounding_metadata::ImageMetadata::new()
                .set_or_clear_image(self.image.map(|v| v.cnv()).transpose()?)
                .set_or_clear_thumbnail(self.thumbnail.map(|v| v.cnv()).transpose()?)
                .set_or_clear_source(self.source.map(|v| v.cnv()).transpose()?)
        )
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::ToProto<generate_grounded_content_response::candidate::GroundingMetadata>
    for crate::model::generate_grounded_content_response::candidate::GroundingMetadata
{
    type Output = generate_grounded_content_response::candidate::GroundingMetadata;
    fn to_proto(
        self,
    ) -> std::result::Result<
        generate_grounded_content_response::candidate::GroundingMetadata,
        gaxi::prost::ConvertError,
    > {
        Ok(Self::Output {
            retrieval_metadata: self
                .retrieval_metadata
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            support_chunks: self
                .support_chunks
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            web_search_queries: self
                .web_search_queries
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            search_entry_point: self.search_entry_point.map(|v| v.to_proto()).transpose()?,
            grounding_support: self
                .grounding_support
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            images: self
                .images
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
        })
    }
}

#[cfg(feature = "grounded-generation-service")]
impl
    gaxi::prost::FromProto<
        crate::model::generate_grounded_content_response::candidate::GroundingMetadata,
    > for generate_grounded_content_response::candidate::GroundingMetadata
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::generate_grounded_content_response::candidate::GroundingMetadata,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::generate_grounded_content_response::candidate::GroundingMetadata::new()
                .set_retrieval_metadata(
                    self.retrieval_metadata
                        .into_iter()
                        .map(|v| v.cnv())
                        .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
                )
                .set_support_chunks(
                    self.support_chunks
                        .into_iter()
                        .map(|v| v.cnv())
                        .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
                )
                .set_web_search_queries(
                    self.web_search_queries
                        .into_iter()
                        .map(|v| v.cnv())
                        .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
                )
                .set_or_clear_search_entry_point(
                    self.search_entry_point.map(|v| v.cnv()).transpose()?,
                )
                .set_grounding_support(
                    self.grounding_support
                        .into_iter()
                        .map(|v| v.cnv())
                        .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
                )
                .set_images(
                    self.images
                        .into_iter()
                        .map(|v| v.cnv())
                        .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
                ),
        )
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::ToProto<generate_grounded_content_response::Candidate>
    for crate::model::generate_grounded_content_response::Candidate
{
    type Output = generate_grounded_content_response::Candidate;
    fn to_proto(
        self,
    ) -> std::result::Result<generate_grounded_content_response::Candidate, gaxi::prost::ConvertError>
    {
        Ok(Self::Output {
            index: self.index.to_proto()?,
            content: self.content.map(|v| v.to_proto()).transpose()?,
            grounding_score: self.grounding_score.map(|v| v.to_proto()).transpose()?,
            grounding_metadata: self.grounding_metadata.map(|v| v.to_proto()).transpose()?,
        })
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::FromProto<crate::model::generate_grounded_content_response::Candidate>
    for generate_grounded_content_response::Candidate
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::generate_grounded_content_response::Candidate,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::generate_grounded_content_response::Candidate::new()
                .set_index(self.index)
                .set_or_clear_content(self.content.map(|v| v.cnv()).transpose()?)
                .set_or_clear_grounding_score(self.grounding_score.map(|v| v.cnv()).transpose()?)
                .set_or_clear_grounding_metadata(
                    self.grounding_metadata.map(|v| v.cnv()).transpose()?,
                ),
        )
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::ToProto<GenerateGroundedContentResponse>
    for crate::model::GenerateGroundedContentResponse
{
    type Output = GenerateGroundedContentResponse;
    fn to_proto(
        self,
    ) -> std::result::Result<GenerateGroundedContentResponse, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            candidates: self
                .candidates
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
        })
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::FromProto<crate::model::GenerateGroundedContentResponse>
    for GenerateGroundedContentResponse
{
    fn cnv(
        self,
    ) -> std::result::Result<crate::model::GenerateGroundedContentResponse, gaxi::prost::ConvertError>
    {
        Ok(
            crate::model::GenerateGroundedContentResponse::new().set_candidates(
                self.candidates
                    .into_iter()
                    .map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            ),
        )
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::ToProto<GroundingFact> for crate::model::GroundingFact {
    type Output = GroundingFact;
    fn to_proto(self) -> std::result::Result<GroundingFact, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            fact_text: self.fact_text.to_proto()?,
            attributes: self
                .attributes
                .into_iter()
                .map(|(k, v)| gaxi::prost::pair_transpose(k.to_proto(), v.to_proto()))
                .collect::<std::result::Result<std::collections::HashMap<_, _>, _>>()?,
        })
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::FromProto<crate::model::GroundingFact> for GroundingFact {
    fn cnv(self) -> std::result::Result<crate::model::GroundingFact, gaxi::prost::ConvertError> {
        Ok(crate::model::GroundingFact::new()
            .set_fact_text(self.fact_text)
            .set_attributes(
                self.attributes
                    .into_iter()
                    .map(|(k, v)| gaxi::prost::pair_transpose(k.cnv(), v.cnv()))
                    .collect::<std::result::Result<std::collections::HashMap<_, _>, _>>()?,
            ))
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::ToProto<FactChunk> for crate::model::FactChunk {
    type Output = FactChunk;
    fn to_proto(self) -> std::result::Result<FactChunk, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            chunk_text: self.chunk_text.to_proto()?,
            source: self.source.to_proto()?,
            index: self.index.to_proto()?,
            source_metadata: self
                .source_metadata
                .into_iter()
                .map(|(k, v)| gaxi::prost::pair_transpose(k.to_proto(), v.to_proto()))
                .collect::<std::result::Result<std::collections::HashMap<_, _>, _>>()?,
            uri: self.uri.to_proto()?,
            title: self.title.to_proto()?,
            domain: self.domain.to_proto()?,
        })
    }
}

#[cfg(feature = "grounded-generation-service")]
impl gaxi::prost::FromProto<crate::model::FactChunk> for FactChunk {
    fn cnv(self) -> std::result::Result<crate::model::FactChunk, gaxi::prost::ConvertError> {
        Ok(crate::model::FactChunk::new()
            .set_chunk_text(self.chunk_text)
            .set_source(self.source)
            .set_index(self.index)
            .set_source_metadata(
                self.source_metadata
                    .into_iter()
                    .map(|(k, v)| gaxi::prost::pair_transpose(k.cnv(), v.cnv()))
                    .collect::<std::result::Result<std::collections::HashMap<_, _>, _>>()?,
            )
            .set_uri(self.uri)
            .set_title(self.title)
            .set_domain(self.domain))
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::ToProto<safety_rating::HarmProbability>
    for crate::model::safety_rating::HarmProbability
{
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value()
            .ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue(
                "crate::model::safety_rating::HarmProbability",
            ))
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::ToProto<safety_rating::HarmSeverity>
    for crate::model::safety_rating::HarmSeverity
{
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value()
            .ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue(
                "crate::model::safety_rating::HarmSeverity",
            ))
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::ToProto<SafetyRating> for crate::model::SafetyRating {
    type Output = SafetyRating;
    fn to_proto(self) -> std::result::Result<SafetyRating, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            category: self.category.to_proto()?,
            probability: self.probability.to_proto()?,
            probability_score: self.probability_score.to_proto()?,
            severity: self.severity.to_proto()?,
            severity_score: self.severity_score.to_proto()?,
            blocked: self.blocked.to_proto()?,
        })
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::FromProto<crate::model::SafetyRating> for SafetyRating {
    fn cnv(self) -> std::result::Result<crate::model::SafetyRating, gaxi::prost::ConvertError> {
        Ok(crate::model::SafetyRating::new()
            .set_category(self.category)
            .set_probability(self.probability)
            .set_probability_score(self.probability_score)
            .set_severity(self.severity)
            .set_severity_score(self.severity_score)
            .set_blocked(self.blocked))
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<search_request::image_query::Image>
    for crate::model::search_request::image_query::Image
{
    type Output = search_request::image_query::Image;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        match self {
            Self::ImageBytes(v) => Ok(Self::Output::ImageBytes(v.to_proto()?)),
        }
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::FromProto<crate::model::search_request::image_query::Image>
    for search_request::image_query::Image
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::search_request::image_query::Image,
        gaxi::prost::ConvertError,
    > {
        use crate::model::search_request::image_query::Image as T;
        match self {
            Self::ImageBytes(v) => Ok(T::ImageBytes(v.cnv()?)),
        }
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<search_request::ImageQuery> for crate::model::search_request::ImageQuery {
    type Output = search_request::ImageQuery;
    fn to_proto(
        self,
    ) -> std::result::Result<search_request::ImageQuery, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            image: self.image.map(|v| v.to_proto()).transpose()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::FromProto<crate::model::search_request::ImageQuery>
    for search_request::ImageQuery
{
    fn cnv(
        self,
    ) -> std::result::Result<crate::model::search_request::ImageQuery, gaxi::prost::ConvertError>
    {
        Ok(crate::model::search_request::ImageQuery::new()
            .set_image(self.image.map(|v| v.cnv()).transpose()?))
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<search_request::DataStoreSpec>
    for crate::model::search_request::DataStoreSpec
{
    type Output = search_request::DataStoreSpec;
    fn to_proto(
        self,
    ) -> std::result::Result<search_request::DataStoreSpec, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            data_store: self.data_store.to_proto()?,
            filter: self.filter.to_proto()?,
            boost_spec: self.boost_spec.map(|v| v.to_proto()).transpose()?,
            custom_search_operators: self.custom_search_operators.to_proto()?,
            num_results: self.num_results.to_proto()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::FromProto<crate::model::search_request::DataStoreSpec>
    for search_request::DataStoreSpec
{
    fn cnv(
        self,
    ) -> std::result::Result<crate::model::search_request::DataStoreSpec, gaxi::prost::ConvertError>
    {
        Ok(crate::model::search_request::DataStoreSpec::new()
            .set_data_store(self.data_store)
            .set_filter(self.filter)
            .set_or_clear_boost_spec(self.boost_spec.map(|v| v.cnv()).transpose()?)
            .set_custom_search_operators(self.custom_search_operators)
            .set_num_results(self.num_results))
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<search_request::facet_spec::FacetKey>
    for crate::model::search_request::facet_spec::FacetKey
{
    type Output = search_request::facet_spec::FacetKey;
    fn to_proto(
        self,
    ) -> std::result::Result<search_request::facet_spec::FacetKey, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            key: self.key.to_proto()?,
            intervals: self
                .intervals
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            restricted_values: self
                .restricted_values
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            prefixes: self
                .prefixes
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            contains: self
                .contains
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            case_insensitive: self.case_insensitive.to_proto()?,
            order_by: self.order_by.to_proto()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::FromProto<crate::model::search_request::facet_spec::FacetKey>
    for search_request::facet_spec::FacetKey
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::search_request::facet_spec::FacetKey,
        gaxi::prost::ConvertError,
    > {
        Ok(crate::model::search_request::facet_spec::FacetKey::new()
            .set_key(self.key)
            .set_intervals(
                self.intervals
                    .into_iter()
                    .map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            )
            .set_restricted_values(
                self.restricted_values
                    .into_iter()
                    .map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            )
            .set_prefixes(
                self.prefixes
                    .into_iter()
                    .map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            )
            .set_contains(
                self.contains
                    .into_iter()
                    .map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            )
            .set_case_insensitive(self.case_insensitive)
            .set_order_by(self.order_by))
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<search_request::FacetSpec> for crate::model::search_request::FacetSpec {
    type Output = search_request::FacetSpec;
    fn to_proto(self) -> std::result::Result<search_request::FacetSpec, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            facet_key: self.facet_key.map(|v| v.to_proto()).transpose()?,
            limit: self.limit.to_proto()?,
            excluded_filter_keys: self
                .excluded_filter_keys
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            enable_dynamic_position: self.enable_dynamic_position.to_proto()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::FromProto<crate::model::search_request::FacetSpec> for search_request::FacetSpec {
    fn cnv(
        self,
    ) -> std::result::Result<crate::model::search_request::FacetSpec, gaxi::prost::ConvertError>
    {
        Ok(crate::model::search_request::FacetSpec::new()
            .set_or_clear_facet_key(self.facet_key.map(|v| v.cnv()).transpose()?)
            .set_limit(self.limit)
            .set_excluded_filter_keys(
                self.excluded_filter_keys
                    .into_iter()
                    .map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            )
            .set_enable_dynamic_position(self.enable_dynamic_position))
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<search_request::boost_spec::condition_boost_spec::boost_control_spec::ControlPoint> for crate::model::search_request::boost_spec::condition_boost_spec::boost_control_spec::ControlPoint {
    type Output = search_request::boost_spec::condition_boost_spec::boost_control_spec::ControlPoint;
    fn to_proto(self) -> std::result::Result<search_request::boost_spec::condition_boost_spec::boost_control_spec::ControlPoint, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            attribute_value: self.attribute_value.to_proto()?,
            boost_amount: self.boost_amount.to_proto()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::FromProto<crate::model::search_request::boost_spec::condition_boost_spec::boost_control_spec::ControlPoint> for search_request::boost_spec::condition_boost_spec::boost_control_spec::ControlPoint {
    fn cnv(self) -> std::result::Result<crate::model::search_request::boost_spec::condition_boost_spec::boost_control_spec::ControlPoint, gaxi::prost::ConvertError> {
        Ok(
            crate::model::search_request::boost_spec::condition_boost_spec::boost_control_spec::ControlPoint::new()
                .set_attribute_value(self.attribute_value)
                .set_boost_amount(self.boost_amount)
        )
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<search_request::boost_spec::condition_boost_spec::boost_control_spec::AttributeType> for crate::model::search_request::boost_spec::condition_boost_spec::boost_control_spec::AttributeType {
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value().ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue("crate::model::search_request::boost_spec::condition_boost_spec::boost_control_spec::AttributeType"))
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<search_request::boost_spec::condition_boost_spec::boost_control_spec::InterpolationType> for crate::model::search_request::boost_spec::condition_boost_spec::boost_control_spec::InterpolationType {
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value().ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue("crate::model::search_request::boost_spec::condition_boost_spec::boost_control_spec::InterpolationType"))
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<search_request::boost_spec::condition_boost_spec::BoostControlSpec>
    for crate::model::search_request::boost_spec::condition_boost_spec::BoostControlSpec
{
    type Output = search_request::boost_spec::condition_boost_spec::BoostControlSpec;
    fn to_proto(
        self,
    ) -> std::result::Result<
        search_request::boost_spec::condition_boost_spec::BoostControlSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(Self::Output {
            field_name: self.field_name.to_proto()?,
            attribute_type: self.attribute_type.to_proto()?,
            interpolation_type: self.interpolation_type.to_proto()?,
            control_points: self
                .control_points
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl
    gaxi::prost::FromProto<
        crate::model::search_request::boost_spec::condition_boost_spec::BoostControlSpec,
    > for search_request::boost_spec::condition_boost_spec::BoostControlSpec
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::search_request::boost_spec::condition_boost_spec::BoostControlSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::search_request::boost_spec::condition_boost_spec::BoostControlSpec::new()
                .set_field_name(self.field_name)
                .set_attribute_type(self.attribute_type)
                .set_interpolation_type(self.interpolation_type)
                .set_control_points(
                    self.control_points
                        .into_iter()
                        .map(|v| v.cnv())
                        .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
                ),
        )
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<search_request::boost_spec::ConditionBoostSpec>
    for crate::model::search_request::boost_spec::ConditionBoostSpec
{
    type Output = search_request::boost_spec::ConditionBoostSpec;
    fn to_proto(
        self,
    ) -> std::result::Result<
        search_request::boost_spec::ConditionBoostSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(Self::Output {
            condition: self.condition.to_proto()?,
            boost: self.boost.to_proto()?,
            boost_control_spec: self.boost_control_spec.map(|v| v.to_proto()).transpose()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::FromProto<crate::model::search_request::boost_spec::ConditionBoostSpec>
    for search_request::boost_spec::ConditionBoostSpec
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::search_request::boost_spec::ConditionBoostSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::search_request::boost_spec::ConditionBoostSpec::new()
                .set_condition(self.condition)
                .set_boost(self.boost)
                .set_or_clear_boost_control_spec(
                    self.boost_control_spec.map(|v| v.cnv()).transpose()?,
                ),
        )
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<search_request::BoostSpec> for crate::model::search_request::BoostSpec {
    type Output = search_request::BoostSpec;
    fn to_proto(self) -> std::result::Result<search_request::BoostSpec, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            condition_boost_specs: self
                .condition_boost_specs
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::FromProto<crate::model::search_request::BoostSpec> for search_request::BoostSpec {
    fn cnv(
        self,
    ) -> std::result::Result<crate::model::search_request::BoostSpec, gaxi::prost::ConvertError>
    {
        Ok(
            crate::model::search_request::BoostSpec::new().set_condition_boost_specs(
                self.condition_boost_specs
                    .into_iter()
                    .map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            ),
        )
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<search_request::query_expansion_spec::Condition>
    for crate::model::search_request::query_expansion_spec::Condition
{
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value()
            .ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue(
                "crate::model::search_request::query_expansion_spec::Condition",
            ))
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<search_request::QueryExpansionSpec>
    for crate::model::search_request::QueryExpansionSpec
{
    type Output = search_request::QueryExpansionSpec;
    fn to_proto(
        self,
    ) -> std::result::Result<search_request::QueryExpansionSpec, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            condition: self.condition.to_proto()?,
            pin_unexpanded_results: self.pin_unexpanded_results.to_proto()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::FromProto<crate::model::search_request::QueryExpansionSpec>
    for search_request::QueryExpansionSpec
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::search_request::QueryExpansionSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(crate::model::search_request::QueryExpansionSpec::new()
            .set_condition(self.condition)
            .set_pin_unexpanded_results(self.pin_unexpanded_results))
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<search_request::spell_correction_spec::Mode>
    for crate::model::search_request::spell_correction_spec::Mode
{
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value()
            .ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue(
                "crate::model::search_request::spell_correction_spec::Mode",
            ))
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<search_request::SpellCorrectionSpec>
    for crate::model::search_request::SpellCorrectionSpec
{
    type Output = search_request::SpellCorrectionSpec;
    fn to_proto(
        self,
    ) -> std::result::Result<search_request::SpellCorrectionSpec, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            mode: self.mode.to_proto()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::FromProto<crate::model::search_request::SpellCorrectionSpec>
    for search_request::SpellCorrectionSpec
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::search_request::SpellCorrectionSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(crate::model::search_request::SpellCorrectionSpec::new().set_mode(self.mode))
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<search_request::content_search_spec::SnippetSpec>
    for crate::model::search_request::content_search_spec::SnippetSpec
{
    type Output = search_request::content_search_spec::SnippetSpec;
    fn to_proto(
        self,
    ) -> std::result::Result<
        search_request::content_search_spec::SnippetSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(Self::Output {
            max_snippet_count: self.max_snippet_count.to_proto()?,
            reference_only: self.reference_only.to_proto()?,
            return_snippet: self.return_snippet.to_proto()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::FromProto<crate::model::search_request::content_search_spec::SnippetSpec>
    for search_request::content_search_spec::SnippetSpec
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::search_request::content_search_spec::SnippetSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::search_request::content_search_spec::SnippetSpec::new()
                .set_max_snippet_count(self.max_snippet_count)
                .set_reference_only(self.reference_only)
                .set_return_snippet(self.return_snippet),
        )
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<search_request::content_search_spec::summary_spec::ModelPromptSpec>
    for crate::model::search_request::content_search_spec::summary_spec::ModelPromptSpec
{
    type Output = search_request::content_search_spec::summary_spec::ModelPromptSpec;
    fn to_proto(
        self,
    ) -> std::result::Result<
        search_request::content_search_spec::summary_spec::ModelPromptSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(Self::Output {
            preamble: self.preamble.to_proto()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl
    gaxi::prost::FromProto<
        crate::model::search_request::content_search_spec::summary_spec::ModelPromptSpec,
    > for search_request::content_search_spec::summary_spec::ModelPromptSpec
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::search_request::content_search_spec::summary_spec::ModelPromptSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::search_request::content_search_spec::summary_spec::ModelPromptSpec::new()
                .set_preamble(self.preamble),
        )
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<search_request::content_search_spec::summary_spec::ModelSpec>
    for crate::model::search_request::content_search_spec::summary_spec::ModelSpec
{
    type Output = search_request::content_search_spec::summary_spec::ModelSpec;
    fn to_proto(
        self,
    ) -> std::result::Result<
        search_request::content_search_spec::summary_spec::ModelSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(Self::Output {
            version: self.version.to_proto()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl
    gaxi::prost::FromProto<
        crate::model::search_request::content_search_spec::summary_spec::ModelSpec,
    > for search_request::content_search_spec::summary_spec::ModelSpec
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::search_request::content_search_spec::summary_spec::ModelSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::search_request::content_search_spec::summary_spec::ModelSpec::new()
                .set_version(self.version),
        )
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<search_request::content_search_spec::SummarySpec>
    for crate::model::search_request::content_search_spec::SummarySpec
{
    type Output = search_request::content_search_spec::SummarySpec;
    fn to_proto(
        self,
    ) -> std::result::Result<
        search_request::content_search_spec::SummarySpec,
        gaxi::prost::ConvertError,
    > {
        Ok(Self::Output {
            summary_result_count: self.summary_result_count.to_proto()?,
            include_citations: self.include_citations.to_proto()?,
            ignore_adversarial_query: self.ignore_adversarial_query.to_proto()?,
            ignore_non_summary_seeking_query: self.ignore_non_summary_seeking_query.to_proto()?,
            ignore_low_relevant_content: self.ignore_low_relevant_content.to_proto()?,
            ignore_jail_breaking_query: self.ignore_jail_breaking_query.to_proto()?,
            model_prompt_spec: self.model_prompt_spec.map(|v| v.to_proto()).transpose()?,
            language_code: self.language_code.to_proto()?,
            model_spec: self.model_spec.map(|v| v.to_proto()).transpose()?,
            use_semantic_chunks: self.use_semantic_chunks.to_proto()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::FromProto<crate::model::search_request::content_search_spec::SummarySpec>
    for search_request::content_search_spec::SummarySpec
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::search_request::content_search_spec::SummarySpec,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::search_request::content_search_spec::SummarySpec::new()
                .set_summary_result_count(self.summary_result_count)
                .set_include_citations(self.include_citations)
                .set_ignore_adversarial_query(self.ignore_adversarial_query)
                .set_ignore_non_summary_seeking_query(self.ignore_non_summary_seeking_query)
                .set_ignore_low_relevant_content(self.ignore_low_relevant_content)
                .set_ignore_jail_breaking_query(self.ignore_jail_breaking_query)
                .set_or_clear_model_prompt_spec(
                    self.model_prompt_spec.map(|v| v.cnv()).transpose()?,
                )
                .set_language_code(self.language_code)
                .set_or_clear_model_spec(self.model_spec.map(|v| v.cnv()).transpose()?)
                .set_use_semantic_chunks(self.use_semantic_chunks),
        )
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<search_request::content_search_spec::ExtractiveContentSpec>
    for crate::model::search_request::content_search_spec::ExtractiveContentSpec
{
    type Output = search_request::content_search_spec::ExtractiveContentSpec;
    fn to_proto(
        self,
    ) -> std::result::Result<
        search_request::content_search_spec::ExtractiveContentSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(Self::Output {
            max_extractive_answer_count: self.max_extractive_answer_count.to_proto()?,
            max_extractive_segment_count: self.max_extractive_segment_count.to_proto()?,
            return_extractive_segment_score: self.return_extractive_segment_score.to_proto()?,
            num_previous_segments: self.num_previous_segments.to_proto()?,
            num_next_segments: self.num_next_segments.to_proto()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl
    gaxi::prost::FromProto<crate::model::search_request::content_search_spec::ExtractiveContentSpec>
    for search_request::content_search_spec::ExtractiveContentSpec
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::search_request::content_search_spec::ExtractiveContentSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::search_request::content_search_spec::ExtractiveContentSpec::new()
                .set_max_extractive_answer_count(self.max_extractive_answer_count)
                .set_max_extractive_segment_count(self.max_extractive_segment_count)
                .set_return_extractive_segment_score(self.return_extractive_segment_score)
                .set_num_previous_segments(self.num_previous_segments)
                .set_num_next_segments(self.num_next_segments),
        )
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<search_request::content_search_spec::ChunkSpec>
    for crate::model::search_request::content_search_spec::ChunkSpec
{
    type Output = search_request::content_search_spec::ChunkSpec;
    fn to_proto(
        self,
    ) -> std::result::Result<
        search_request::content_search_spec::ChunkSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(Self::Output {
            num_previous_chunks: self.num_previous_chunks.to_proto()?,
            num_next_chunks: self.num_next_chunks.to_proto()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::FromProto<crate::model::search_request::content_search_spec::ChunkSpec>
    for search_request::content_search_spec::ChunkSpec
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::search_request::content_search_spec::ChunkSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::search_request::content_search_spec::ChunkSpec::new()
                .set_num_previous_chunks(self.num_previous_chunks)
                .set_num_next_chunks(self.num_next_chunks),
        )
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<search_request::content_search_spec::SearchResultMode>
    for crate::model::search_request::content_search_spec::SearchResultMode
{
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value()
            .ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue(
                "crate::model::search_request::content_search_spec::SearchResultMode",
            ))
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<search_request::ContentSearchSpec>
    for crate::model::search_request::ContentSearchSpec
{
    type Output = search_request::ContentSearchSpec;
    fn to_proto(
        self,
    ) -> std::result::Result<search_request::ContentSearchSpec, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            snippet_spec: self.snippet_spec.map(|v| v.to_proto()).transpose()?,
            summary_spec: self.summary_spec.map(|v| v.to_proto()).transpose()?,
            extractive_content_spec: self
                .extractive_content_spec
                .map(|v| v.to_proto())
                .transpose()?,
            search_result_mode: self.search_result_mode.to_proto()?,
            chunk_spec: self.chunk_spec.map(|v| v.to_proto()).transpose()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::FromProto<crate::model::search_request::ContentSearchSpec>
    for search_request::ContentSearchSpec
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::search_request::ContentSearchSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(crate::model::search_request::ContentSearchSpec::new()
            .set_or_clear_snippet_spec(self.snippet_spec.map(|v| v.cnv()).transpose()?)
            .set_or_clear_summary_spec(self.summary_spec.map(|v| v.cnv()).transpose()?)
            .set_or_clear_extractive_content_spec(
                self.extractive_content_spec.map(|v| v.cnv()).transpose()?,
            )
            .set_search_result_mode(self.search_result_mode)
            .set_or_clear_chunk_spec(self.chunk_spec.map(|v| v.cnv()).transpose()?))
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<search_request::natural_language_query_understanding_spec::FilterExtractionCondition> for crate::model::search_request::natural_language_query_understanding_spec::FilterExtractionCondition {
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value().ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue("crate::model::search_request::natural_language_query_understanding_spec::FilterExtractionCondition"))
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<search_request::natural_language_query_understanding_spec::ExtractedFilterBehavior> for crate::model::search_request::natural_language_query_understanding_spec::ExtractedFilterBehavior {
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value().ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue("crate::model::search_request::natural_language_query_understanding_spec::ExtractedFilterBehavior"))
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<search_request::NaturalLanguageQueryUnderstandingSpec>
    for crate::model::search_request::NaturalLanguageQueryUnderstandingSpec
{
    type Output = search_request::NaturalLanguageQueryUnderstandingSpec;
    fn to_proto(
        self,
    ) -> std::result::Result<
        search_request::NaturalLanguageQueryUnderstandingSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(Self::Output {
            filter_extraction_condition: self.filter_extraction_condition.to_proto()?,
            geo_search_query_detection_field_names: self
                .geo_search_query_detection_field_names
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            extracted_filter_behavior: self.extracted_filter_behavior.to_proto()?,
            allowed_field_names: self
                .allowed_field_names
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::FromProto<crate::model::search_request::NaturalLanguageQueryUnderstandingSpec>
    for search_request::NaturalLanguageQueryUnderstandingSpec
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::search_request::NaturalLanguageQueryUnderstandingSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::search_request::NaturalLanguageQueryUnderstandingSpec::new()
                .set_filter_extraction_condition(self.filter_extraction_condition)
                .set_geo_search_query_detection_field_names(
                    self.geo_search_query_detection_field_names
                        .into_iter()
                        .map(|v| v.cnv())
                        .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
                )
                .set_extracted_filter_behavior(self.extracted_filter_behavior)
                .set_allowed_field_names(
                    self.allowed_field_names
                        .into_iter()
                        .map(|v| v.cnv())
                        .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
                ),
        )
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<search_request::search_as_you_type_spec::Field>
    for crate::model::search_request::search_as_you_type_spec::Field
{
    type Output = search_request::search_as_you_type_spec::Field;
    fn to_proto(
        self,
    ) -> std::result::Result<
        search_request::search_as_you_type_spec::Field,
        gaxi::prost::ConvertError,
    > {
        Ok(Self::Output {
            key: self.key.to_proto()?,
            weight: self.weight.map(|v| v.to_proto()).transpose()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::FromProto<crate::model::search_request::search_as_you_type_spec::Field>
    for search_request::search_as_you_type_spec::Field
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::search_request::search_as_you_type_spec::Field,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::search_request::search_as_you_type_spec::Field::new()
                .set_key(self.key)
                .set_or_clear_weight(self.weight.map(|v| v.cnv()).transpose()?),
        )
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<search_request::search_as_you_type_spec::Condition>
    for crate::model::search_request::search_as_you_type_spec::Condition
{
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value()
            .ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue(
                "crate::model::search_request::search_as_you_type_spec::Condition",
            ))
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<search_request::SearchAsYouTypeSpec>
    for crate::model::search_request::SearchAsYouTypeSpec
{
    type Output = search_request::SearchAsYouTypeSpec;
    fn to_proto(
        self,
    ) -> std::result::Result<search_request::SearchAsYouTypeSpec, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            condition: self.condition.to_proto()?,
            fields: self
                .fields
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            score_threshold: self.score_threshold.map(|v| v.to_proto()).transpose()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::FromProto<crate::model::search_request::SearchAsYouTypeSpec>
    for search_request::SearchAsYouTypeSpec
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::search_request::SearchAsYouTypeSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(crate::model::search_request::SearchAsYouTypeSpec::new()
            .set_condition(self.condition)
            .set_fields(
                self.fields
                    .into_iter()
                    .map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            )
            .set_or_clear_score_threshold(self.score_threshold.map(|v| v.cnv()).transpose()?))
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<search_request::display_spec::MatchHighlightingCondition>
    for crate::model::search_request::display_spec::MatchHighlightingCondition
{
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value()
            .ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue(
                "crate::model::search_request::display_spec::MatchHighlightingCondition",
            ))
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<search_request::DisplaySpec>
    for crate::model::search_request::DisplaySpec
{
    type Output = search_request::DisplaySpec;
    fn to_proto(
        self,
    ) -> std::result::Result<search_request::DisplaySpec, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            match_highlighting_condition: self.match_highlighting_condition.to_proto()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::FromProto<crate::model::search_request::DisplaySpec>
    for search_request::DisplaySpec
{
    fn cnv(
        self,
    ) -> std::result::Result<crate::model::search_request::DisplaySpec, gaxi::prost::ConvertError>
    {
        Ok(crate::model::search_request::DisplaySpec::new()
            .set_match_highlighting_condition(self.match_highlighting_condition))
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<search_request::crowding_spec::Mode>
    for crate::model::search_request::crowding_spec::Mode
{
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value()
            .ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue(
                "crate::model::search_request::crowding_spec::Mode",
            ))
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<search_request::CrowdingSpec>
    for crate::model::search_request::CrowdingSpec
{
    type Output = search_request::CrowdingSpec;
    fn to_proto(
        self,
    ) -> std::result::Result<search_request::CrowdingSpec, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            field: self.field.to_proto()?,
            max_count: self.max_count.to_proto()?,
            mode: self.mode.to_proto()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::FromProto<crate::model::search_request::CrowdingSpec>
    for search_request::CrowdingSpec
{
    fn cnv(
        self,
    ) -> std::result::Result<crate::model::search_request::CrowdingSpec, gaxi::prost::ConvertError>
    {
        Ok(crate::model::search_request::CrowdingSpec::new()
            .set_field(self.field)
            .set_max_count(self.max_count)
            .set_mode(self.mode))
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<search_request::SessionSpec>
    for crate::model::search_request::SessionSpec
{
    type Output = search_request::SessionSpec;
    fn to_proto(
        self,
    ) -> std::result::Result<search_request::SessionSpec, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            query_id: self.query_id.to_proto()?,
            search_result_persistence_count: self
                .search_result_persistence_count
                .map(|v| v.to_proto())
                .transpose()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::FromProto<crate::model::search_request::SessionSpec>
    for search_request::SessionSpec
{
    fn cnv(
        self,
    ) -> std::result::Result<crate::model::search_request::SessionSpec, gaxi::prost::ConvertError>
    {
        Ok(crate::model::search_request::SessionSpec::new()
            .set_query_id(self.query_id)
            .set_or_clear_search_result_persistence_count(
                self.search_result_persistence_count
                    .map(|v| v.cnv())
                    .transpose()?,
            ))
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<search_request::relevance_filter_spec::relevance_threshold_spec::RelevanceThresholdSpec> for crate::model::search_request::relevance_filter_spec::relevance_threshold_spec::RelevanceThresholdSpec {
    type Output = search_request::relevance_filter_spec::relevance_threshold_spec::RelevanceThresholdSpec;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        match self {
            Self::RelevanceThreshold(v) => Ok(Self::Output::RelevanceThreshold(v.to_proto()?)),
            Self::SemanticRelevanceThreshold(v) => Ok(Self::Output::SemanticRelevanceThreshold(v.to_proto()?)),
        }
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::FromProto<crate::model::search_request::relevance_filter_spec::relevance_threshold_spec::RelevanceThresholdSpec> for search_request::relevance_filter_spec::relevance_threshold_spec::RelevanceThresholdSpec {
    fn cnv(self) -> std::result::Result<crate::model::search_request::relevance_filter_spec::relevance_threshold_spec::RelevanceThresholdSpec, gaxi::prost::ConvertError> {
        use crate::model::search_request::relevance_filter_spec::relevance_threshold_spec::RelevanceThresholdSpec as T;
        match self {
            Self::RelevanceThreshold(v) => Ok(T::RelevanceThreshold(v.into())),
            Self::SemanticRelevanceThreshold(v) => Ok(T::SemanticRelevanceThreshold(v.cnv()?)),
        }
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<search_request::relevance_filter_spec::RelevanceThresholdSpec>
    for crate::model::search_request::relevance_filter_spec::RelevanceThresholdSpec
{
    type Output = search_request::relevance_filter_spec::RelevanceThresholdSpec;
    fn to_proto(
        self,
    ) -> std::result::Result<
        search_request::relevance_filter_spec::RelevanceThresholdSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(Self::Output {
            relevance_threshold_spec: self
                .relevance_threshold_spec
                .map(|v| v.to_proto())
                .transpose()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl
    gaxi::prost::FromProto<
        crate::model::search_request::relevance_filter_spec::RelevanceThresholdSpec,
    > for search_request::relevance_filter_spec::RelevanceThresholdSpec
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::search_request::relevance_filter_spec::RelevanceThresholdSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::search_request::relevance_filter_spec::RelevanceThresholdSpec::new()
                .set_relevance_threshold_spec(
                    self.relevance_threshold_spec.map(|v| v.cnv()).transpose()?,
                ),
        )
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<search_request::RelevanceFilterSpec>
    for crate::model::search_request::RelevanceFilterSpec
{
    type Output = search_request::RelevanceFilterSpec;
    fn to_proto(
        self,
    ) -> std::result::Result<search_request::RelevanceFilterSpec, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            keyword_search_threshold: self
                .keyword_search_threshold
                .map(|v| v.to_proto())
                .transpose()?,
            semantic_search_threshold: self
                .semantic_search_threshold
                .map(|v| v.to_proto())
                .transpose()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::FromProto<crate::model::search_request::RelevanceFilterSpec>
    for search_request::RelevanceFilterSpec
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::search_request::RelevanceFilterSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(crate::model::search_request::RelevanceFilterSpec::new()
            .set_or_clear_keyword_search_threshold(
                self.keyword_search_threshold.map(|v| v.cnv()).transpose()?,
            )
            .set_or_clear_semantic_search_threshold(
                self.semantic_search_threshold
                    .map(|v| v.cnv())
                    .transpose()?,
            ))
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<search_request::RelevanceScoreSpec>
    for crate::model::search_request::RelevanceScoreSpec
{
    type Output = search_request::RelevanceScoreSpec;
    fn to_proto(
        self,
    ) -> std::result::Result<search_request::RelevanceScoreSpec, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            return_relevance_score: self.return_relevance_score.to_proto()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::FromProto<crate::model::search_request::RelevanceScoreSpec>
    for search_request::RelevanceScoreSpec
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::search_request::RelevanceScoreSpec,
        gaxi::prost::ConvertError,
    > {
        Ok(crate::model::search_request::RelevanceScoreSpec::new()
            .set_return_relevance_score(self.return_relevance_score))
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<search_request::SearchAddonSpec>
    for crate::model::search_request::SearchAddonSpec
{
    type Output = search_request::SearchAddonSpec;
    fn to_proto(
        self,
    ) -> std::result::Result<search_request::SearchAddonSpec, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            disable_semantic_add_on: self.disable_semantic_add_on.to_proto()?,
            disable_kpi_personalization_add_on: self
                .disable_kpi_personalization_add_on
                .to_proto()?,
            disable_generative_answer_add_on: self.disable_generative_answer_add_on.to_proto()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::FromProto<crate::model::search_request::SearchAddonSpec>
    for search_request::SearchAddonSpec
{
    fn cnv(
        self,
    ) -> std::result::Result<crate::model::search_request::SearchAddonSpec, gaxi::prost::ConvertError>
    {
        Ok(crate::model::search_request::SearchAddonSpec::new()
            .set_disable_semantic_add_on(self.disable_semantic_add_on)
            .set_disable_kpi_personalization_add_on(self.disable_kpi_personalization_add_on)
            .set_disable_generative_answer_add_on(self.disable_generative_answer_add_on))
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<search_request::CustomRankingParams>
    for crate::model::search_request::CustomRankingParams
{
    type Output = search_request::CustomRankingParams;
    fn to_proto(
        self,
    ) -> std::result::Result<search_request::CustomRankingParams, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            expressions_to_precompute: self
                .expressions_to_precompute
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::FromProto<crate::model::search_request::CustomRankingParams>
    for search_request::CustomRankingParams
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::search_request::CustomRankingParams,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::search_request::CustomRankingParams::new().set_expressions_to_precompute(
                self.expressions_to_precompute
                    .into_iter()
                    .map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            ),
        )
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<search_request::RankingExpressionBackend>
    for crate::model::search_request::RankingExpressionBackend
{
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value()
            .ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue(
                "crate::model::search_request::RankingExpressionBackend",
            ))
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<search_request::RelevanceThreshold>
    for crate::model::search_request::RelevanceThreshold
{
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value()
            .ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue(
                "crate::model::search_request::RelevanceThreshold",
            ))
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::ToProto<SearchRequest> for crate::model::SearchRequest {
    type Output = SearchRequest;
    fn to_proto(self) -> std::result::Result<SearchRequest, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            serving_config: self.serving_config.to_proto()?,
            branch: self.branch.to_proto()?,
            query: self.query.to_proto()?,
            page_categories: self
                .page_categories
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            image_query: self.image_query.map(|v| v.to_proto()).transpose()?,
            page_size: self.page_size.to_proto()?,
            page_token: self.page_token.to_proto()?,
            offset: self.offset.to_proto()?,
            one_box_page_size: self.one_box_page_size.to_proto()?,
            data_store_specs: self
                .data_store_specs
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            num_results_per_data_store: self.num_results_per_data_store.to_proto()?,
            filter: self.filter.to_proto()?,
            canonical_filter: self.canonical_filter.to_proto()?,
            order_by: self.order_by.to_proto()?,
            user_info: self.user_info.map(|v| v.to_proto()).transpose()?,
            language_code: self.language_code.to_proto()?,
            facet_specs: self
                .facet_specs
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            boost_spec: self.boost_spec.map(|v| v.to_proto()).transpose()?,
            params: self
                .params
                .into_iter()
                .map(|(k, v)| gaxi::prost::pair_transpose(k.to_proto(), v.to_proto()))
                .collect::<std::result::Result<std::collections::HashMap<_, _>, _>>()?,
            query_expansion_spec: self
                .query_expansion_spec
                .map(|v| v.to_proto())
                .transpose()?,
            spell_correction_spec: self
                .spell_correction_spec
                .map(|v| v.to_proto())
                .transpose()?,
            user_pseudo_id: self.user_pseudo_id.to_proto()?,
            content_search_spec: self.content_search_spec.map(|v| v.to_proto()).transpose()?,
            ranking_expression: self.ranking_expression.to_proto()?,
            ranking_expression_backend: self.ranking_expression_backend.to_proto()?,
            safe_search: self.safe_search.to_proto()?,
            user_labels: self
                .user_labels
                .into_iter()
                .map(|(k, v)| gaxi::prost::pair_transpose(k.to_proto(), v.to_proto()))
                .collect::<std::result::Result<std::collections::HashMap<_, _>, _>>()?,
            natural_language_query_understanding_spec: self
                .natural_language_query_understanding_spec
                .map(|v| v.to_proto())
                .transpose()?,
            search_as_you_type_spec: self
                .search_as_you_type_spec
                .map(|v| v.to_proto())
                .transpose()?,
            display_spec: self.display_spec.map(|v| v.to_proto()).transpose()?,
            crowding_specs: self
                .crowding_specs
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            session: self.session.to_proto()?,
            session_spec: self.session_spec.map(|v| v.to_proto()).transpose()?,
            relevance_threshold: self.relevance_threshold.to_proto()?,
            relevance_filter_spec: self
                .relevance_filter_spec
                .map(|v| v.to_proto())
                .transpose()?,
            relevance_score_spec: self
                .relevance_score_spec
                .map(|v| v.to_proto())
                .transpose()?,
            search_addon_spec: self.search_addon_spec.map(|v| v.to_proto()).transpose()?,
            custom_ranking_params: self
                .custom_ranking_params
                .map(|v| v.to_proto())
                .transpose()?,
            entity: self.entity.to_proto()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl gaxi::prost::FromProto<crate::model::SearchRequest> for SearchRequest {
    fn cnv(self) -> std::result::Result<crate::model::SearchRequest, gaxi::prost::ConvertError> {
        Ok(crate::model::SearchRequest::new()
            .set_serving_config(self.serving_config)
            .set_branch(self.branch)
            .set_query(self.query)
            .set_page_categories(
                self.page_categories
                    .into_iter()
                    .map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            )
            .set_or_clear_image_query(self.image_query.map(|v| v.cnv()).transpose()?)
            .set_page_size(self.page_size)
            .set_page_token(self.page_token)
            .set_offset(self.offset)
            .set_one_box_page_size(self.one_box_page_size)
            .set_data_store_specs(
                self.data_store_specs
                    .into_iter()
                    .map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            )
            .set_num_results_per_data_store(self.num_results_per_data_store)
            .set_filter(self.filter)
            .set_canonical_filter(self.canonical_filter)
            .set_order_by(self.order_by)
            .set_or_clear_user_info(self.user_info.map(|v| v.cnv()).transpose()?)
            .set_language_code(self.language_code)
            .set_facet_specs(
                self.facet_specs
                    .into_iter()
                    .map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            )
            .set_or_clear_boost_spec(self.boost_spec.map(|v| v.cnv()).transpose()?)
            .set_params(
                self.params
                    .into_iter()
                    .map(|(k, v)| gaxi::prost::pair_transpose(k.cnv(), v.cnv()))
                    .collect::<std::result::Result<std::collections::HashMap<_, _>, _>>()?,
            )
            .set_or_clear_query_expansion_spec(
                self.query_expansion_spec.map(|v| v.cnv()).transpose()?,
            )
            .set_or_clear_spell_correction_spec(
                self.spell_correction_spec.map(|v| v.cnv()).transpose()?,
            )
            .set_user_pseudo_id(self.user_pseudo_id)
            .set_or_clear_content_search_spec(
                self.content_search_spec.map(|v| v.cnv()).transpose()?,
            )
            .set_ranking_expression(self.ranking_expression)
            .set_ranking_expression_backend(self.ranking_expression_backend)
            .set_safe_search(self.safe_search)
            .set_user_labels(
                self.user_labels
                    .into_iter()
                    .map(|(k, v)| gaxi::prost::pair_transpose(k.cnv(), v.cnv()))
                    .collect::<std::result::Result<std::collections::HashMap<_, _>, _>>()?,
            )
            .set_or_clear_natural_language_query_understanding_spec(
                self.natural_language_query_understanding_spec
                    .map(|v| v.cnv())
                    .transpose()?,
            )
            .set_or_clear_search_as_you_type_spec(
                self.search_as_you_type_spec.map(|v| v.cnv()).transpose()?,
            )
            .set_or_clear_display_spec(self.display_spec.map(|v| v.cnv()).transpose()?)
            .set_crowding_specs(
                self.crowding_specs
                    .into_iter()
                    .map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            )
            .set_session(self.session)
            .set_or_clear_session_spec(self.session_spec.map(|v| v.cnv()).transpose()?)
            .set_relevance_threshold(self.relevance_threshold)
            .set_or_clear_relevance_filter_spec(
                self.relevance_filter_spec.map(|v| v.cnv()).transpose()?,
            )
            .set_or_clear_relevance_score_spec(
                self.relevance_score_spec.map(|v| v.cnv()).transpose()?,
            )
            .set_or_clear_search_addon_spec(self.search_addon_spec.map(|v| v.cnv()).transpose()?)
            .set_or_clear_custom_ranking_params(
                self.custom_ranking_params.map(|v| v.cnv()).transpose()?,
            )
            .set_entity(self.entity))
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::ToProto<session::Turn> for crate::model::session::Turn {
    type Output = session::Turn;
    fn to_proto(self) -> std::result::Result<session::Turn, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            query: self.query.map(|v| v.to_proto()).transpose()?,
            answer: self.answer.to_proto()?,
            detailed_answer: self.detailed_answer.map(|v| v.to_proto()).transpose()?,
            detailed_assist_answer: self
                .detailed_assist_answer
                .map(|v| v.to_proto())
                .transpose()?,
            query_config: self
                .query_config
                .into_iter()
                .map(|(k, v)| gaxi::prost::pair_transpose(k.to_proto(), v.to_proto()))
                .collect::<std::result::Result<std::collections::HashMap<_, _>, _>>()?,
        })
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::FromProto<crate::model::session::Turn> for session::Turn {
    fn cnv(self) -> std::result::Result<crate::model::session::Turn, gaxi::prost::ConvertError> {
        Ok(crate::model::session::Turn::new()
            .set_or_clear_query(self.query.map(|v| v.cnv()).transpose()?)
            .set_answer(self.answer)
            .set_or_clear_detailed_answer(self.detailed_answer.map(|v| v.cnv()).transpose()?)
            .set_or_clear_detailed_assist_answer(
                self.detailed_assist_answer.map(|v| v.cnv()).transpose()?,
            )
            .set_query_config(
                self.query_config
                    .into_iter()
                    .map(|(k, v)| gaxi::prost::pair_transpose(k.cnv(), v.cnv()))
                    .collect::<std::result::Result<std::collections::HashMap<_, _>, _>>()?,
            ))
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::ToProto<session::State> for crate::model::session::State {
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value()
            .ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue(
                "crate::model::session::State",
            ))
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::ToProto<Session> for crate::model::Session {
    type Output = Session;
    fn to_proto(self) -> std::result::Result<Session, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            name: self.name.to_proto()?,
            display_name: self.display_name.to_proto()?,
            state: self.state.to_proto()?,
            user_pseudo_id: self.user_pseudo_id.to_proto()?,
            turns: self
                .turns
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            labels: self
                .labels
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            start_time: self.start_time.map(|v| v.to_proto()).transpose()?,
            end_time: self.end_time.map(|v| v.to_proto()).transpose()?,
            is_pinned: self.is_pinned.to_proto()?,
        })
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl gaxi::prost::FromProto<crate::model::Session> for Session {
    fn cnv(self) -> std::result::Result<crate::model::Session, gaxi::prost::ConvertError> {
        Ok(crate::model::Session::new()
            .set_name(self.name)
            .set_display_name(self.display_name)
            .set_state(self.state)
            .set_user_pseudo_id(self.user_pseudo_id)
            .set_turns(
                self.turns
                    .into_iter()
                    .map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            )
            .set_labels(
                self.labels
                    .into_iter()
                    .map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            )
            .set_or_clear_start_time(self.start_time.map(|v| v.cnv()).transpose()?)
            .set_or_clear_end_time(self.end_time.map(|v| v.cnv()).transpose()?)
            .set_is_pinned(self.is_pinned))
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl gaxi::prost::ToProto<query::Content> for crate::model::query::Content {
    type Output = query::Content;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        match self {
            Self::Text(v) => Ok(Self::Output::Text(v.to_proto()?)),
        }
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl gaxi::prost::FromProto<crate::model::query::Content> for query::Content {
    fn cnv(self) -> std::result::Result<crate::model::query::Content, gaxi::prost::ConvertError> {
        use crate::model::query::Content as T;
        match self {
            Self::Text(v) => Ok(T::Text(v.cnv()?)),
        }
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl gaxi::prost::ToProto<Query> for crate::model::Query {
    type Output = Query;
    fn to_proto(self) -> std::result::Result<Query, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            query_id: self.query_id.to_proto()?,
            content: self.content.map(|v| v.to_proto()).transpose()?,
        })
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl gaxi::prost::FromProto<crate::model::Query> for Query {
    fn cnv(self) -> std::result::Result<crate::model::Query, gaxi::prost::ConvertError> {
        Ok(crate::model::Query::new()
            .set_query_id(self.query_id)
            .set_content(self.content.map(|v| v.cnv()).transpose()?))
    }
}