google_cloud_discoveryengine_v1/model/

debug.rs

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

#[allow(unused_imports)]
use super::*;

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl std::fmt::Debug for super::Answer {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Answer");
        debug_struct.field("name", &self.name);
        debug_struct.field("state", &self.state);
        debug_struct.field("answer_text", &self.answer_text);
        debug_struct.field("grounding_score", &self.grounding_score);
        debug_struct.field("citations", &self.citations);
        debug_struct.field("grounding_supports", &self.grounding_supports);
        debug_struct.field("references", &self.references);
        debug_struct.field("related_questions", &self.related_questions);
        debug_struct.field("steps", &self.steps);
        debug_struct.field("query_understanding_info", &self.query_understanding_info);
        debug_struct.field("answer_skipped_reasons", &self.answer_skipped_reasons);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("complete_time", &self.complete_time);
        debug_struct.field("safety_ratings", &self.safety_ratings);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl std::fmt::Debug for super::answer::Citation {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Citation");
        debug_struct.field("start_index", &self.start_index);
        debug_struct.field("end_index", &self.end_index);
        debug_struct.field("sources", &self.sources);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl std::fmt::Debug for super::answer::CitationSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CitationSource");
        debug_struct.field("reference_id", &self.reference_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl std::fmt::Debug for super::answer::GroundingSupport {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GroundingSupport");
        debug_struct.field("start_index", &self.start_index);
        debug_struct.field("end_index", &self.end_index);
        debug_struct.field("grounding_score", &self.grounding_score);
        debug_struct.field("grounding_check_required", &self.grounding_check_required);
        debug_struct.field("sources", &self.sources);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl std::fmt::Debug for super::answer::Reference {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Reference");
        debug_struct.field("content", &self.content);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl std::fmt::Debug for super::answer::reference::UnstructuredDocumentInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UnstructuredDocumentInfo");
        debug_struct.field("document", &self.document);
        debug_struct.field("uri", &self.uri);
        debug_struct.field("title", &self.title);
        debug_struct.field("chunk_contents", &self.chunk_contents);
        debug_struct.field("struct_data", &self.struct_data);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl std::fmt::Debug for super::answer::reference::unstructured_document_info::ChunkContent {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ChunkContent");
        debug_struct.field("content", &self.content);
        debug_struct.field("page_identifier", &self.page_identifier);
        debug_struct.field("relevance_score", &self.relevance_score);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl std::fmt::Debug for super::answer::reference::ChunkInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ChunkInfo");
        debug_struct.field("chunk", &self.chunk);
        debug_struct.field("content", &self.content);
        debug_struct.field("relevance_score", &self.relevance_score);
        debug_struct.field("document_metadata", &self.document_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl std::fmt::Debug for super::answer::reference::chunk_info::DocumentMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DocumentMetadata");
        debug_struct.field("document", &self.document);
        debug_struct.field("uri", &self.uri);
        debug_struct.field("title", &self.title);
        debug_struct.field("page_identifier", &self.page_identifier);
        debug_struct.field("struct_data", &self.struct_data);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl std::fmt::Debug for super::answer::reference::StructuredDocumentInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("StructuredDocumentInfo");
        debug_struct.field("document", &self.document);
        debug_struct.field("struct_data", &self.struct_data);
        debug_struct.field("title", &self.title);
        debug_struct.field("uri", &self.uri);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl std::fmt::Debug for super::answer::Step {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Step");
        debug_struct.field("state", &self.state);
        debug_struct.field("description", &self.description);
        debug_struct.field("thought", &self.thought);
        debug_struct.field("actions", &self.actions);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl std::fmt::Debug for super::answer::step::Action {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Action");
        debug_struct.field("observation", &self.observation);
        debug_struct.field("action", &self.action);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl std::fmt::Debug for super::answer::step::action::SearchAction {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SearchAction");
        debug_struct.field("query", &self.query);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl std::fmt::Debug for super::answer::step::action::Observation {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Observation");
        debug_struct.field("search_results", &self.search_results);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl std::fmt::Debug for super::answer::step::action::observation::SearchResult {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SearchResult");
        debug_struct.field("document", &self.document);
        debug_struct.field("uri", &self.uri);
        debug_struct.field("title", &self.title);
        debug_struct.field("snippet_info", &self.snippet_info);
        debug_struct.field("chunk_info", &self.chunk_info);
        debug_struct.field("struct_data", &self.struct_data);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl std::fmt::Debug for super::answer::step::action::observation::search_result::SnippetInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SnippetInfo");
        debug_struct.field("snippet", &self.snippet);
        debug_struct.field("snippet_status", &self.snippet_status);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl std::fmt::Debug for super::answer::step::action::observation::search_result::ChunkInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ChunkInfo");
        debug_struct.field("chunk", &self.chunk);
        debug_struct.field("content", &self.content);
        debug_struct.field("relevance_score", &self.relevance_score);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl std::fmt::Debug for super::answer::QueryUnderstandingInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("QueryUnderstandingInfo");
        debug_struct.field("query_classification_info", &self.query_classification_info);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl std::fmt::Debug for super::answer::query_understanding_info::QueryClassificationInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("QueryClassificationInfo");
        debug_struct.field("r#type", &self.r#type);
        debug_struct.field("positive", &self.positive);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl std::fmt::Debug for super::AssistAnswer {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AssistAnswer");
        debug_struct.field("name", &self.name);
        debug_struct.field("state", &self.state);
        debug_struct.field("replies", &self.replies);
        debug_struct.field("assist_skipped_reasons", &self.assist_skipped_reasons);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl std::fmt::Debug for super::assist_answer::Reply {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Reply");
        debug_struct.field("reply", &self.reply);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl std::fmt::Debug for super::AssistantContent {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AssistantContent");
        debug_struct.field("role", &self.role);
        debug_struct.field("thought", &self.thought);
        debug_struct.field("data", &self.data);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl std::fmt::Debug for super::assistant_content::Blob {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Blob");
        debug_struct.field("mime_type", &self.mime_type);
        debug_struct.field("data", &self.data);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl std::fmt::Debug for super::assistant_content::File {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("File");
        debug_struct.field("mime_type", &self.mime_type);
        debug_struct.field("file_id", &self.file_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl std::fmt::Debug for super::assistant_content::ExecutableCode {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExecutableCode");
        debug_struct.field("code", &self.code);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl std::fmt::Debug for super::assistant_content::CodeExecutionResult {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CodeExecutionResult");
        debug_struct.field("outcome", &self.outcome);
        debug_struct.field("output", &self.output);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl std::fmt::Debug for super::AssistantGroundedContent {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AssistantGroundedContent");
        debug_struct.field("content", &self.content);
        debug_struct.field("metadata", &self.metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl std::fmt::Debug for super::assistant_grounded_content::TextGroundingMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TextGroundingMetadata");
        debug_struct.field("segments", &self.segments);
        debug_struct.field("references", &self.references);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl std::fmt::Debug for super::assistant_grounded_content::text_grounding_metadata::Segment {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Segment");
        debug_struct.field("start_index", &self.start_index);
        debug_struct.field("end_index", &self.end_index);
        debug_struct.field("reference_indices", &self.reference_indices);
        debug_struct.field("grounding_score", &self.grounding_score);
        debug_struct.field("text", &self.text);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl std::fmt::Debug for super::assistant_grounded_content::text_grounding_metadata::Reference {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Reference");
        debug_struct.field("content", &self.content);
        debug_struct.field("document_metadata", &self.document_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl std::fmt::Debug
    for super::assistant_grounded_content::text_grounding_metadata::reference::DocumentMetadata
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DocumentMetadata");
        debug_struct.field("document", &self.document);
        debug_struct.field("uri", &self.uri);
        debug_struct.field("title", &self.title);
        debug_struct.field("page_identifier", &self.page_identifier);
        debug_struct.field("domain", &self.domain);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(all(
    feature = "assistant-service",
    feature = "cmek-config-service",
    feature = "completion-service",
    feature = "control-service",
    feature = "conversational-search-service",
    feature = "data-store-service",
    feature = "document-service",
    feature = "engine-service",
    feature = "grounded-generation-service",
    feature = "identity-mapping-store-service",
    feature = "project-service",
    feature = "rank-service",
    feature = "recommendation-service",
    feature = "schema-service",
    feature = "search-service",
    feature = "search-tuning-service",
    feature = "serving-config-service",
    feature = "session-service",
    feature = "site-search-engine-service",
    feature = "user-event-service",
    feature = "user-license-service",
))]
impl std::fmt::Debug for super::Assistant {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Assistant");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "assistant-service")]
impl std::fmt::Debug for super::AssistUserMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AssistUserMetadata");
        debug_struct.field("time_zone", &self.time_zone);
        debug_struct.field("preferred_language_code", &self.preferred_language_code);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "assistant-service")]
impl std::fmt::Debug for super::StreamAssistRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("StreamAssistRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("query", &self.query);
        debug_struct.field("session", &self.session);
        debug_struct.field("user_metadata", &self.user_metadata);
        debug_struct.field("tools_spec", &self.tools_spec);
        debug_struct.field("generation_spec", &self.generation_spec);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "assistant-service")]
impl std::fmt::Debug for super::stream_assist_request::ToolsSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ToolsSpec");
        debug_struct.field("vertex_ai_search_spec", &self.vertex_ai_search_spec);
        debug_struct.field("web_grounding_spec", &self.web_grounding_spec);
        debug_struct.field("image_generation_spec", &self.image_generation_spec);
        debug_struct.field("video_generation_spec", &self.video_generation_spec);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "assistant-service")]
impl std::fmt::Debug for super::stream_assist_request::tools_spec::VertexAiSearchSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("VertexAiSearchSpec");
        debug_struct.field("data_store_specs", &self.data_store_specs);
        debug_struct.field("filter", &self.filter);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "assistant-service")]
impl std::fmt::Debug for super::stream_assist_request::tools_spec::WebGroundingSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("WebGroundingSpec");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "assistant-service")]
impl std::fmt::Debug for super::stream_assist_request::tools_spec::ImageGenerationSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ImageGenerationSpec");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "assistant-service")]
impl std::fmt::Debug for super::stream_assist_request::tools_spec::VideoGenerationSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("VideoGenerationSpec");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "assistant-service")]
impl std::fmt::Debug for super::stream_assist_request::GenerationSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GenerationSpec");
        debug_struct.field("model_id", &self.model_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "assistant-service")]
impl std::fmt::Debug for super::StreamAssistResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("StreamAssistResponse");
        debug_struct.field("answer", &self.answer);
        debug_struct.field("session_info", &self.session_info);
        debug_struct.field("assist_token", &self.assist_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "assistant-service")]
impl std::fmt::Debug for super::stream_assist_response::SessionInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SessionInfo");
        debug_struct.field("session", &self.session);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
impl std::fmt::Debug for super::Chunk {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Chunk");
        debug_struct.field("name", &self.name);
        debug_struct.field("id", &self.id);
        debug_struct.field("content", &self.content);
        debug_struct.field("relevance_score", &self.relevance_score);
        debug_struct.field("document_metadata", &self.document_metadata);
        debug_struct.field("derived_struct_data", &self.derived_struct_data);
        debug_struct.field("page_span", &self.page_span);
        debug_struct.field("chunk_metadata", &self.chunk_metadata);
        debug_struct.field("data_urls", &self.data_urls);
        debug_struct.field("annotation_contents", &self.annotation_contents);
        debug_struct.field("annotation_metadata", &self.annotation_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
impl std::fmt::Debug for super::chunk::DocumentMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DocumentMetadata");
        debug_struct.field("uri", &self.uri);
        debug_struct.field("title", &self.title);
        debug_struct.field("struct_data", &self.struct_data);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
impl std::fmt::Debug for super::chunk::PageSpan {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PageSpan");
        debug_struct.field("page_start", &self.page_start);
        debug_struct.field("page_end", &self.page_end);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
impl std::fmt::Debug for super::chunk::ChunkMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ChunkMetadata");
        debug_struct.field("previous_chunks", &self.previous_chunks);
        debug_struct.field("next_chunks", &self.next_chunks);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
impl std::fmt::Debug for super::chunk::StructuredContent {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("StructuredContent");
        debug_struct.field("structure_type", &self.structure_type);
        debug_struct.field("content", &self.content);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
impl std::fmt::Debug for super::chunk::AnnotationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AnnotationMetadata");
        debug_struct.field("structured_content", &self.structured_content);
        debug_struct.field("image_id", &self.image_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "cmek-config-service")]
impl std::fmt::Debug for super::UpdateCmekConfigRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateCmekConfigRequest");
        debug_struct.field("config", &self.config);
        debug_struct.field("set_default", &self.set_default);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "cmek-config-service")]
impl std::fmt::Debug for super::GetCmekConfigRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetCmekConfigRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "cmek-config-service",
    feature = "data-store-service",
    feature = "identity-mapping-store-service",
))]
impl std::fmt::Debug for super::SingleRegionKey {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SingleRegionKey");
        debug_struct.field("kms_key", &self.kms_key);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "cmek-config-service",
    feature = "data-store-service",
    feature = "identity-mapping-store-service",
))]
impl std::fmt::Debug for super::CmekConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CmekConfig");
        debug_struct.field("name", &self.name);
        debug_struct.field("kms_key", &self.kms_key);
        debug_struct.field("kms_key_version", &self.kms_key_version);
        debug_struct.field("state", &self.state);
        debug_struct.field("is_default", &self.is_default);
        debug_struct.field(
            "last_rotation_timestamp_micros",
            &self.last_rotation_timestamp_micros,
        );
        debug_struct.field("single_region_keys", &self.single_region_keys);
        debug_struct.field("notebooklm_state", &self.notebooklm_state);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "cmek-config-service")]
impl std::fmt::Debug for super::UpdateCmekConfigMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateCmekConfigMetadata");
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "cmek-config-service")]
impl std::fmt::Debug for super::ListCmekConfigsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListCmekConfigsRequest");
        debug_struct.field("parent", &self.parent);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "cmek-config-service")]
impl std::fmt::Debug for super::ListCmekConfigsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListCmekConfigsResponse");
        debug_struct.field("cmek_configs", &self.cmek_configs);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "cmek-config-service")]
impl std::fmt::Debug for super::DeleteCmekConfigRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteCmekConfigRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "cmek-config-service")]
impl std::fmt::Debug for super::DeleteCmekConfigMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteCmekConfigMetadata");
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl std::fmt::Debug for super::Interval {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Interval");
        debug_struct.field("min", &self.min);
        debug_struct.field("max", &self.max);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "recommendation-service", feature = "user-event-service",))]
impl std::fmt::Debug for super::CustomAttribute {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CustomAttribute");
        debug_struct.field("text", &self.text);
        debug_struct.field("numbers", &self.numbers);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "recommendation-service",
    feature = "search-service",
    feature = "serving-config-service",
    feature = "user-event-service",
))]
impl std::fmt::Debug for super::UserInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UserInfo");
        debug_struct.field("user_id", &self.user_id);
        debug_struct.field("user_agent", &self.user_agent);
        debug_struct.field("time_zone", &self.time_zone);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
impl std::fmt::Debug for super::DoubleList {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DoubleList");
        debug_struct.field("values", &self.values);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "conversational-search-service",
    feature = "document-service",
    feature = "recommendation-service",
    feature = "search-service",
))]
impl std::fmt::Debug for super::Principal {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Principal");
        debug_struct.field("principal", &self.principal);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "data-store-service")]
impl std::fmt::Debug for super::HealthcareFhirConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("HealthcareFhirConfig");
        debug_struct.field(
            "enable_configurable_schema",
            &self.enable_configurable_schema,
        );
        debug_struct.field(
            "enable_static_indexing_for_batch_ingestion",
            &self.enable_static_indexing_for_batch_ingestion,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "control-service",
    feature = "conversational-search-service",
    feature = "search-service",
))]
impl std::fmt::Debug for super::SearchLinkPromotion {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SearchLinkPromotion");
        debug_struct.field("title", &self.title);
        debug_struct.field("uri", &self.uri);
        debug_struct.field("document", &self.document);
        debug_struct.field("image_uri", &self.image_uri);
        debug_struct.field("description", &self.description);
        debug_struct.field("enabled", &self.enabled);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "completion-service")]
impl std::fmt::Debug for super::SuggestionDenyListEntry {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SuggestionDenyListEntry");
        debug_struct.field("block_phrase", &self.block_phrase);
        debug_struct.field("match_operator", &self.match_operator);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "completion-service")]
impl std::fmt::Debug for super::CompletionSuggestion {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CompletionSuggestion");
        debug_struct.field("suggestion", &self.suggestion);
        debug_struct.field("language_code", &self.language_code);
        debug_struct.field("group_id", &self.group_id);
        debug_struct.field("group_score", &self.group_score);
        debug_struct.field("alternative_phrases", &self.alternative_phrases);
        debug_struct.field("ranking_info", &self.ranking_info);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "completion-service")]
impl std::fmt::Debug for super::CompleteQueryRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CompleteQueryRequest");
        debug_struct.field("data_store", &self.data_store);
        debug_struct.field("query", &self.query);
        debug_struct.field("query_model", &self.query_model);
        debug_struct.field("user_pseudo_id", &self.user_pseudo_id);
        debug_struct.field("include_tail_suggestions", &self.include_tail_suggestions);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "completion-service")]
impl std::fmt::Debug for super::CompleteQueryResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CompleteQueryResponse");
        debug_struct.field("query_suggestions", &self.query_suggestions);
        debug_struct.field("tail_match_triggered", &self.tail_match_triggered);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "completion-service")]
impl std::fmt::Debug for super::complete_query_response::QuerySuggestion {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("QuerySuggestion");
        debug_struct.field("suggestion", &self.suggestion);
        debug_struct.field("completable_field_paths", &self.completable_field_paths);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "control-service")]
impl std::fmt::Debug for super::Condition {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Condition");
        debug_struct.field("query_terms", &self.query_terms);
        debug_struct.field("active_time_range", &self.active_time_range);
        debug_struct.field("query_regex", &self.query_regex);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "control-service")]
impl std::fmt::Debug for super::condition::QueryTerm {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("QueryTerm");
        debug_struct.field("value", &self.value);
        debug_struct.field("full_match", &self.full_match);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "control-service")]
impl std::fmt::Debug for super::condition::TimeRange {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TimeRange");
        debug_struct.field("start_time", &self.start_time);
        debug_struct.field("end_time", &self.end_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "control-service")]
impl std::fmt::Debug for super::Control {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Control");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field(
            "associated_serving_config_ids",
            &self.associated_serving_config_ids,
        );
        debug_struct.field("solution_type", &self.solution_type);
        debug_struct.field("use_cases", &self.use_cases);
        debug_struct.field("conditions", &self.conditions);
        debug_struct.field("action", &self.action);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "control-service")]
impl std::fmt::Debug for super::control::BoostAction {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BoostAction");
        debug_struct.field("boost", &self.boost);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("data_store", &self.data_store);
        debug_struct.field("boost_spec", &self.boost_spec);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "control-service")]
impl std::fmt::Debug for super::control::boost_action::InterpolationBoostSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("InterpolationBoostSpec");
        debug_struct.field("field_name", &self.field_name);
        debug_struct.field("attribute_type", &self.attribute_type);
        debug_struct.field("interpolation_type", &self.interpolation_type);
        debug_struct.field("control_points", &self.control_points);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "control-service")]
impl std::fmt::Debug for super::control::boost_action::interpolation_boost_spec::ControlPoint {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ControlPoint");
        debug_struct.field("attribute_value", &self.attribute_value);
        debug_struct.field("boost_amount", &self.boost_amount);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "control-service")]
impl std::fmt::Debug for super::control::FilterAction {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FilterAction");
        debug_struct.field("filter", &self.filter);
        debug_struct.field("data_store", &self.data_store);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "control-service")]
impl std::fmt::Debug for super::control::RedirectAction {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RedirectAction");
        debug_struct.field("redirect_uri", &self.redirect_uri);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "control-service")]
impl std::fmt::Debug for super::control::SynonymsAction {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SynonymsAction");
        debug_struct.field("synonyms", &self.synonyms);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "control-service")]
impl std::fmt::Debug for super::control::PromoteAction {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PromoteAction");
        debug_struct.field("data_store", &self.data_store);
        debug_struct.field("search_link_promotion", &self.search_link_promotion);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "control-service")]
impl std::fmt::Debug for super::CreateControlRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateControlRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("control", &self.control);
        debug_struct.field("control_id", &self.control_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "control-service")]
impl std::fmt::Debug for super::UpdateControlRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateControlRequest");
        debug_struct.field("control", &self.control);
        debug_struct.field("update_mask", &self.update_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "control-service")]
impl std::fmt::Debug for super::DeleteControlRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteControlRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "control-service")]
impl std::fmt::Debug for super::GetControlRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetControlRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "control-service")]
impl std::fmt::Debug for super::ListControlsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListControlsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("filter", &self.filter);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "control-service")]
impl std::fmt::Debug for super::ListControlsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListControlsResponse");
        debug_struct.field("controls", &self.controls);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversational-search-service")]
impl std::fmt::Debug for super::Conversation {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Conversation");
        debug_struct.field("name", &self.name);
        debug_struct.field("state", &self.state);
        debug_struct.field("user_pseudo_id", &self.user_pseudo_id);
        debug_struct.field("messages", &self.messages);
        debug_struct.field("start_time", &self.start_time);
        debug_struct.field("end_time", &self.end_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversational-search-service")]
impl std::fmt::Debug for super::Reply {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Reply");
        debug_struct.field("summary", &self.summary);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversational-search-service")]
impl std::fmt::Debug for super::ConversationContext {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ConversationContext");
        debug_struct.field("context_documents", &self.context_documents);
        debug_struct.field("active_document", &self.active_document);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversational-search-service")]
impl std::fmt::Debug for super::TextInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TextInput");
        debug_struct.field("input", &self.input);
        debug_struct.field("context", &self.context);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversational-search-service")]
impl std::fmt::Debug for super::ConversationMessage {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ConversationMessage");
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("message", &self.message);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversational-search-service")]
impl std::fmt::Debug for super::ConverseConversationRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ConverseConversationRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("query", &self.query);
        debug_struct.field("serving_config", &self.serving_config);
        debug_struct.field("conversation", &self.conversation);
        debug_struct.field("safe_search", &self.safe_search);
        debug_struct.field("user_labels", &self.user_labels);
        debug_struct.field("summary_spec", &self.summary_spec);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("boost_spec", &self.boost_spec);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversational-search-service")]
impl std::fmt::Debug for super::ConverseConversationResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ConverseConversationResponse");
        debug_struct.field("reply", &self.reply);
        debug_struct.field("conversation", &self.conversation);
        debug_struct.field("search_results", &self.search_results);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversational-search-service")]
impl std::fmt::Debug for super::CreateConversationRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateConversationRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("conversation", &self.conversation);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversational-search-service")]
impl std::fmt::Debug for super::UpdateConversationRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateConversationRequest");
        debug_struct.field("conversation", &self.conversation);
        debug_struct.field("update_mask", &self.update_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversational-search-service")]
impl std::fmt::Debug for super::DeleteConversationRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteConversationRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversational-search-service")]
impl std::fmt::Debug for super::GetConversationRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetConversationRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversational-search-service")]
impl std::fmt::Debug for super::ListConversationsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListConversationsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("order_by", &self.order_by);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversational-search-service")]
impl std::fmt::Debug for super::ListConversationsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListConversationsResponse");
        debug_struct.field("conversations", &self.conversations);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversational-search-service")]
impl std::fmt::Debug for super::AnswerQueryRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AnswerQueryRequest");
        debug_struct.field("serving_config", &self.serving_config);
        debug_struct.field("query", &self.query);
        debug_struct.field("session", &self.session);
        debug_struct.field("safety_spec", &self.safety_spec);
        debug_struct.field("related_questions_spec", &self.related_questions_spec);
        debug_struct.field("grounding_spec", &self.grounding_spec);
        debug_struct.field("answer_generation_spec", &self.answer_generation_spec);
        debug_struct.field("search_spec", &self.search_spec);
        debug_struct.field("query_understanding_spec", &self.query_understanding_spec);
        debug_struct.field("asynchronous_mode", &self.asynchronous_mode);
        debug_struct.field("user_pseudo_id", &self.user_pseudo_id);
        debug_struct.field("user_labels", &self.user_labels);
        debug_struct.field("end_user_spec", &self.end_user_spec);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversational-search-service")]
impl std::fmt::Debug for super::answer_query_request::SafetySpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SafetySpec");
        debug_struct.field("enable", &self.enable);
        debug_struct.field("safety_settings", &self.safety_settings);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversational-search-service")]
impl std::fmt::Debug for super::answer_query_request::safety_spec::SafetySetting {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SafetySetting");
        debug_struct.field("category", &self.category);
        debug_struct.field("threshold", &self.threshold);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversational-search-service")]
impl std::fmt::Debug for super::answer_query_request::RelatedQuestionsSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RelatedQuestionsSpec");
        debug_struct.field("enable", &self.enable);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversational-search-service")]
impl std::fmt::Debug for super::answer_query_request::GroundingSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GroundingSpec");
        debug_struct.field(
            "include_grounding_supports",
            &self.include_grounding_supports,
        );
        debug_struct.field("filtering_level", &self.filtering_level);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversational-search-service")]
impl std::fmt::Debug for super::answer_query_request::AnswerGenerationSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AnswerGenerationSpec");
        debug_struct.field("model_spec", &self.model_spec);
        debug_struct.field("prompt_spec", &self.prompt_spec);
        debug_struct.field("include_citations", &self.include_citations);
        debug_struct.field("answer_language_code", &self.answer_language_code);
        debug_struct.field("ignore_adversarial_query", &self.ignore_adversarial_query);
        debug_struct.field(
            "ignore_non_answer_seeking_query",
            &self.ignore_non_answer_seeking_query,
        );
        debug_struct.field(
            "ignore_low_relevant_content",
            &self.ignore_low_relevant_content,
        );
        debug_struct.field(
            "ignore_jail_breaking_query",
            &self.ignore_jail_breaking_query,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversational-search-service")]
impl std::fmt::Debug for super::answer_query_request::answer_generation_spec::ModelSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ModelSpec");
        debug_struct.field("model_version", &self.model_version);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversational-search-service")]
impl std::fmt::Debug for super::answer_query_request::answer_generation_spec::PromptSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PromptSpec");
        debug_struct.field("preamble", &self.preamble);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversational-search-service")]
impl std::fmt::Debug for super::answer_query_request::SearchSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SearchSpec");
        debug_struct.field("input", &self.input);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversational-search-service")]
impl std::fmt::Debug for super::answer_query_request::search_spec::SearchParams {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SearchParams");
        debug_struct.field("max_return_results", &self.max_return_results);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("boost_spec", &self.boost_spec);
        debug_struct.field("order_by", &self.order_by);
        debug_struct.field("search_result_mode", &self.search_result_mode);
        debug_struct.field("data_store_specs", &self.data_store_specs);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversational-search-service")]
impl std::fmt::Debug for super::answer_query_request::search_spec::SearchResultList {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SearchResultList");
        debug_struct.field("search_results", &self.search_results);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversational-search-service")]
impl std::fmt::Debug
    for super::answer_query_request::search_spec::search_result_list::SearchResult
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SearchResult");
        debug_struct.field("content", &self.content);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversational-search-service")]
impl std::fmt::Debug for super::answer_query_request::search_spec::search_result_list::search_result::UnstructuredDocumentInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UnstructuredDocumentInfo");
        debug_struct.field("document", &self.document);
        debug_struct.field("uri", &self.uri);
        debug_struct.field("title", &self.title);
        debug_struct.field("document_contexts", &self.document_contexts);
        debug_struct.field("extractive_segments", &self.extractive_segments);
        debug_struct.field("extractive_answers", &self.extractive_answers);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversational-search-service")]
impl std::fmt::Debug for super::answer_query_request::search_spec::search_result_list::search_result::unstructured_document_info::DocumentContext {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DocumentContext");
        debug_struct.field("page_identifier", &self.page_identifier);
        debug_struct.field("content", &self.content);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversational-search-service")]
impl std::fmt::Debug for super::answer_query_request::search_spec::search_result_list::search_result::unstructured_document_info::ExtractiveSegment {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExtractiveSegment");
        debug_struct.field("page_identifier", &self.page_identifier);
        debug_struct.field("content", &self.content);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversational-search-service")]
impl std::fmt::Debug for super::answer_query_request::search_spec::search_result_list::search_result::unstructured_document_info::ExtractiveAnswer {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExtractiveAnswer");
        debug_struct.field("page_identifier", &self.page_identifier);
        debug_struct.field("content", &self.content);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversational-search-service")]
impl std::fmt::Debug
    for super::answer_query_request::search_spec::search_result_list::search_result::ChunkInfo
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ChunkInfo");
        debug_struct.field("chunk", &self.chunk);
        debug_struct.field("content", &self.content);
        debug_struct.field("document_metadata", &self.document_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversational-search-service")]
impl std::fmt::Debug for super::answer_query_request::search_spec::search_result_list::search_result::chunk_info::DocumentMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DocumentMetadata");
        debug_struct.field("uri", &self.uri);
        debug_struct.field("title", &self.title);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversational-search-service")]
impl std::fmt::Debug for super::answer_query_request::QueryUnderstandingSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("QueryUnderstandingSpec");
        debug_struct.field("query_classification_spec", &self.query_classification_spec);
        debug_struct.field("query_rephraser_spec", &self.query_rephraser_spec);
        debug_struct.field("disable_spell_correction", &self.disable_spell_correction);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversational-search-service")]
impl std::fmt::Debug
    for super::answer_query_request::query_understanding_spec::QueryClassificationSpec
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("QueryClassificationSpec");
        debug_struct.field("types", &self.types);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversational-search-service")]
impl std::fmt::Debug for super::answer_query_request::query_understanding_spec::QueryRephraserSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("QueryRephraserSpec");
        debug_struct.field("disable", &self.disable);
        debug_struct.field("max_rephrase_steps", &self.max_rephrase_steps);
        debug_struct.field("model_spec", &self.model_spec);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversational-search-service")]
impl std::fmt::Debug
    for super::answer_query_request::query_understanding_spec::query_rephraser_spec::ModelSpec
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ModelSpec");
        debug_struct.field("model_type", &self.model_type);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversational-search-service")]
impl std::fmt::Debug for super::answer_query_request::EndUserSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("EndUserSpec");
        debug_struct.field("end_user_metadata", &self.end_user_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversational-search-service")]
impl std::fmt::Debug for super::answer_query_request::end_user_spec::EndUserMetaData {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("EndUserMetaData");
        debug_struct.field("content", &self.content);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversational-search-service")]
impl std::fmt::Debug for super::answer_query_request::end_user_spec::end_user_meta_data::ChunkInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ChunkInfo");
        debug_struct.field("content", &self.content);
        debug_struct.field("document_metadata", &self.document_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversational-search-service")]
impl std::fmt::Debug
    for super::answer_query_request::end_user_spec::end_user_meta_data::chunk_info::DocumentMetadata
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DocumentMetadata");
        debug_struct.field("title", &self.title);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversational-search-service")]
impl std::fmt::Debug for super::AnswerQueryResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AnswerQueryResponse");
        debug_struct.field("answer", &self.answer);
        debug_struct.field("session", &self.session);
        debug_struct.field("answer_query_token", &self.answer_query_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversational-search-service")]
impl std::fmt::Debug for super::GetAnswerRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetAnswerRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl std::fmt::Debug for super::CreateSessionRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateSessionRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("session", &self.session);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl std::fmt::Debug for super::UpdateSessionRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateSessionRequest");
        debug_struct.field("session", &self.session);
        debug_struct.field("update_mask", &self.update_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl std::fmt::Debug for super::DeleteSessionRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteSessionRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl std::fmt::Debug for super::GetSessionRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetSessionRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("include_answer_details", &self.include_answer_details);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl std::fmt::Debug for super::ListSessionsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListSessionsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("order_by", &self.order_by);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl std::fmt::Debug for super::ListSessionsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListSessionsResponse");
        debug_struct.field("sessions", &self.sessions);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "search-tuning-service")]
impl std::fmt::Debug for super::CustomTuningModel {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CustomTuningModel");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("model_version", &self.model_version);
        debug_struct.field("model_state", &self.model_state);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("training_start_time", &self.training_start_time);
        debug_struct.field("metrics", &self.metrics);
        debug_struct.field("error_message", &self.error_message);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "data-store-service")]
impl std::fmt::Debug for super::DataStore {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DataStore");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("industry_vertical", &self.industry_vertical);
        debug_struct.field("solution_types", &self.solution_types);
        debug_struct.field("default_schema_id", &self.default_schema_id);
        debug_struct.field("content_config", &self.content_config);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field(
            "advanced_site_search_config",
            &self.advanced_site_search_config,
        );
        debug_struct.field("kms_key_name", &self.kms_key_name);
        debug_struct.field("cmek_config", &self.cmek_config);
        debug_struct.field("billing_estimation", &self.billing_estimation);
        debug_struct.field("acl_enabled", &self.acl_enabled);
        debug_struct.field("workspace_config", &self.workspace_config);
        debug_struct.field(
            "document_processing_config",
            &self.document_processing_config,
        );
        debug_struct.field("starting_schema", &self.starting_schema);
        debug_struct.field("healthcare_fhir_config", &self.healthcare_fhir_config);
        debug_struct.field("identity_mapping_store", &self.identity_mapping_store);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "data-store-service")]
impl std::fmt::Debug for super::data_store::BillingEstimation {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BillingEstimation");
        debug_struct.field("structured_data_size", &self.structured_data_size);
        debug_struct.field("unstructured_data_size", &self.unstructured_data_size);
        debug_struct.field("website_data_size", &self.website_data_size);
        debug_struct.field(
            "structured_data_update_time",
            &self.structured_data_update_time,
        );
        debug_struct.field(
            "unstructured_data_update_time",
            &self.unstructured_data_update_time,
        );
        debug_struct.field("website_data_update_time", &self.website_data_update_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "data-store-service")]
impl std::fmt::Debug for super::AdvancedSiteSearchConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AdvancedSiteSearchConfig");
        debug_struct.field("disable_initial_index", &self.disable_initial_index);
        debug_struct.field("disable_automatic_refresh", &self.disable_automatic_refresh);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "data-store-service")]
impl std::fmt::Debug for super::WorkspaceConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("WorkspaceConfig");
        debug_struct.field("r#type", &self.r#type);
        debug_struct.field("dasher_customer_id", &self.dasher_customer_id);
        debug_struct.field(
            "super_admin_service_account",
            &self.super_admin_service_account,
        );
        debug_struct.field("super_admin_email_address", &self.super_admin_email_address);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "data-store-service")]
impl std::fmt::Debug for super::CreateDataStoreRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateDataStoreRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("data_store", &self.data_store);
        debug_struct.field("data_store_id", &self.data_store_id);
        debug_struct.field(
            "create_advanced_site_search",
            &self.create_advanced_site_search,
        );
        debug_struct.field(
            "skip_default_schema_creation",
            &self.skip_default_schema_creation,
        );
        debug_struct.field("cmek_options", &self.cmek_options);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "data-store-service")]
impl std::fmt::Debug for super::GetDataStoreRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetDataStoreRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "data-store-service")]
impl std::fmt::Debug for super::CreateDataStoreMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateDataStoreMetadata");
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "data-store-service")]
impl std::fmt::Debug for super::ListDataStoresRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListDataStoresRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("filter", &self.filter);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "data-store-service")]
impl std::fmt::Debug for super::ListDataStoresResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListDataStoresResponse");
        debug_struct.field("data_stores", &self.data_stores);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "data-store-service")]
impl std::fmt::Debug for super::DeleteDataStoreRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteDataStoreRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "data-store-service")]
impl std::fmt::Debug for super::UpdateDataStoreRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateDataStoreRequest");
        debug_struct.field("data_store", &self.data_store);
        debug_struct.field("update_mask", &self.update_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "data-store-service")]
impl std::fmt::Debug for super::DeleteDataStoreMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteDataStoreMetadata");
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "conversational-search-service",
    feature = "document-service",
    feature = "recommendation-service",
    feature = "search-service",
))]
impl std::fmt::Debug for super::Document {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Document");
        debug_struct.field("name", &self.name);
        debug_struct.field("id", &self.id);
        debug_struct.field("schema_id", &self.schema_id);
        debug_struct.field("content", &self.content);
        debug_struct.field("parent_document_id", &self.parent_document_id);
        debug_struct.field("derived_struct_data", &self.derived_struct_data);
        debug_struct.field("acl_info", &self.acl_info);
        debug_struct.field("index_time", &self.index_time);
        debug_struct.field("index_status", &self.index_status);
        debug_struct.field("data", &self.data);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "conversational-search-service",
    feature = "document-service",
    feature = "recommendation-service",
    feature = "search-service",
))]
impl std::fmt::Debug for super::document::Content {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Content");
        debug_struct.field("mime_type", &self.mime_type);
        debug_struct.field("content", &self.content);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "conversational-search-service",
    feature = "document-service",
    feature = "recommendation-service",
    feature = "search-service",
))]
impl std::fmt::Debug for super::document::AclInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AclInfo");
        debug_struct.field("readers", &self.readers);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "conversational-search-service",
    feature = "document-service",
    feature = "recommendation-service",
    feature = "search-service",
))]
impl std::fmt::Debug for super::document::acl_info::AccessRestriction {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AccessRestriction");
        debug_struct.field("principals", &self.principals);
        debug_struct.field("idp_wide", &self.idp_wide);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "conversational-search-service",
    feature = "document-service",
    feature = "recommendation-service",
    feature = "search-service",
))]
impl std::fmt::Debug for super::document::IndexStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("IndexStatus");
        debug_struct.field("index_time", &self.index_time);
        debug_struct.field("error_samples", &self.error_samples);
        debug_struct.field("pending_message", &self.pending_message);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "data-store-service")]
impl std::fmt::Debug for super::DocumentProcessingConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DocumentProcessingConfig");
        debug_struct.field("name", &self.name);
        debug_struct.field("chunking_config", &self.chunking_config);
        debug_struct.field("default_parsing_config", &self.default_parsing_config);
        debug_struct.field("parsing_config_overrides", &self.parsing_config_overrides);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "data-store-service")]
impl std::fmt::Debug for super::document_processing_config::ChunkingConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ChunkingConfig");
        debug_struct.field("chunk_mode", &self.chunk_mode);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "data-store-service")]
impl std::fmt::Debug
    for super::document_processing_config::chunking_config::LayoutBasedChunkingConfig
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("LayoutBasedChunkingConfig");
        debug_struct.field("chunk_size", &self.chunk_size);
        debug_struct.field("include_ancestor_headings", &self.include_ancestor_headings);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "data-store-service")]
impl std::fmt::Debug for super::document_processing_config::ParsingConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ParsingConfig");
        debug_struct.field("type_dedicated_config", &self.type_dedicated_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "data-store-service")]
impl std::fmt::Debug for super::document_processing_config::parsing_config::DigitalParsingConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DigitalParsingConfig");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "data-store-service")]
impl std::fmt::Debug for super::document_processing_config::parsing_config::OcrParsingConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("OcrParsingConfig");
        debug_struct.field(
            "enhanced_document_elements",
            &self.enhanced_document_elements,
        );
        debug_struct.field("use_native_text", &self.use_native_text);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "data-store-service")]
impl std::fmt::Debug for super::document_processing_config::parsing_config::LayoutParsingConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("LayoutParsingConfig");
        debug_struct.field("enable_table_annotation", &self.enable_table_annotation);
        debug_struct.field("enable_image_annotation", &self.enable_image_annotation);
        debug_struct.field("structured_content_types", &self.structured_content_types);
        debug_struct.field("exclude_html_elements", &self.exclude_html_elements);
        debug_struct.field("exclude_html_classes", &self.exclude_html_classes);
        debug_struct.field("exclude_html_ids", &self.exclude_html_ids);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "document-service")]
impl std::fmt::Debug for super::GetDocumentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetDocumentRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "document-service")]
impl std::fmt::Debug for super::ListDocumentsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListDocumentsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "document-service")]
impl std::fmt::Debug for super::ListDocumentsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListDocumentsResponse");
        debug_struct.field("documents", &self.documents);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "document-service")]
impl std::fmt::Debug for super::CreateDocumentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateDocumentRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("document", &self.document);
        debug_struct.field("document_id", &self.document_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "document-service")]
impl std::fmt::Debug for super::UpdateDocumentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateDocumentRequest");
        debug_struct.field("document", &self.document);
        debug_struct.field("allow_missing", &self.allow_missing);
        debug_struct.field("update_mask", &self.update_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "document-service")]
impl std::fmt::Debug for super::DeleteDocumentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteDocumentRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "document-service")]
impl std::fmt::Debug for super::BatchGetDocumentsMetadataRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchGetDocumentsMetadataRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("matcher", &self.matcher);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "document-service")]
impl std::fmt::Debug for super::batch_get_documents_metadata_request::UrisMatcher {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UrisMatcher");
        debug_struct.field("uris", &self.uris);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "document-service")]
impl std::fmt::Debug for super::batch_get_documents_metadata_request::FhirMatcher {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FhirMatcher");
        debug_struct.field("fhir_resources", &self.fhir_resources);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "document-service")]
impl std::fmt::Debug for super::batch_get_documents_metadata_request::Matcher {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Matcher");
        debug_struct.field("matcher", &self.matcher);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "document-service")]
impl std::fmt::Debug for super::BatchGetDocumentsMetadataResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchGetDocumentsMetadataResponse");
        debug_struct.field("documents_metadata", &self.documents_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "document-service")]
impl std::fmt::Debug for super::batch_get_documents_metadata_response::DocumentMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DocumentMetadata");
        debug_struct.field("matcher_value", &self.matcher_value);
        debug_struct.field("state", &self.state);
        debug_struct.field("last_refreshed_time", &self.last_refreshed_time);
        debug_struct.field("data_ingestion_source", &self.data_ingestion_source);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "document-service")]
impl std::fmt::Debug
    for super::batch_get_documents_metadata_response::document_metadata::MatcherValue
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MatcherValue");
        debug_struct.field("matcher_value", &self.matcher_value);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "engine-service")]
impl std::fmt::Debug for super::Engine {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Engine");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("data_store_ids", &self.data_store_ids);
        debug_struct.field("solution_type", &self.solution_type);
        debug_struct.field("industry_vertical", &self.industry_vertical);
        debug_struct.field("common_config", &self.common_config);
        debug_struct.field("disable_analytics", &self.disable_analytics);
        debug_struct.field("engine_config", &self.engine_config);
        debug_struct.field("engine_metadata", &self.engine_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "engine-service")]
impl std::fmt::Debug for super::engine::SearchEngineConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SearchEngineConfig");
        debug_struct.field("search_tier", &self.search_tier);
        debug_struct.field("search_add_ons", &self.search_add_ons);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "engine-service")]
impl std::fmt::Debug for super::engine::MediaRecommendationEngineConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MediaRecommendationEngineConfig");
        debug_struct.field("r#type", &self.r#type);
        debug_struct.field("optimization_objective", &self.optimization_objective);
        debug_struct.field(
            "optimization_objective_config",
            &self.optimization_objective_config,
        );
        debug_struct.field("training_state", &self.training_state);
        debug_struct.field("engine_features_config", &self.engine_features_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "engine-service")]
impl std::fmt::Debug
    for super::engine::media_recommendation_engine_config::OptimizationObjectiveConfig
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("OptimizationObjectiveConfig");
        debug_struct.field("target_field", &self.target_field);
        debug_struct.field("target_field_value_float", &self.target_field_value_float);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "engine-service")]
impl std::fmt::Debug for super::engine::media_recommendation_engine_config::EngineFeaturesConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("EngineFeaturesConfig");
        debug_struct.field("type_dedicated_config", &self.type_dedicated_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "engine-service")]
impl std::fmt::Debug
    for super::engine::media_recommendation_engine_config::RecommendedForYouFeatureConfig
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RecommendedForYouFeatureConfig");
        debug_struct.field("context_event_type", &self.context_event_type);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "engine-service")]
impl std::fmt::Debug
    for super::engine::media_recommendation_engine_config::MostPopularFeatureConfig
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MostPopularFeatureConfig");
        debug_struct.field("time_window_days", &self.time_window_days);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "engine-service")]
impl std::fmt::Debug for super::engine::ChatEngineConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ChatEngineConfig");
        debug_struct.field("agent_creation_config", &self.agent_creation_config);
        debug_struct.field("dialogflow_agent_to_link", &self.dialogflow_agent_to_link);
        debug_struct.field("allow_cross_region", &self.allow_cross_region);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "engine-service")]
impl std::fmt::Debug for super::engine::chat_engine_config::AgentCreationConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AgentCreationConfig");
        debug_struct.field("business", &self.business);
        debug_struct.field("default_language_code", &self.default_language_code);
        debug_struct.field("time_zone", &self.time_zone);
        debug_struct.field("location", &self.location);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "engine-service")]
impl std::fmt::Debug for super::engine::CommonConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CommonConfig");
        debug_struct.field("company_name", &self.company_name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "engine-service")]
impl std::fmt::Debug for super::engine::ChatEngineMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ChatEngineMetadata");
        debug_struct.field("dialogflow_agent", &self.dialogflow_agent);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "engine-service")]
impl std::fmt::Debug for super::CreateEngineRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateEngineRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("engine", &self.engine);
        debug_struct.field("engine_id", &self.engine_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "engine-service")]
impl std::fmt::Debug for super::CreateEngineMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateEngineMetadata");
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "engine-service")]
impl std::fmt::Debug for super::DeleteEngineRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteEngineRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "engine-service")]
impl std::fmt::Debug for super::DeleteEngineMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteEngineMetadata");
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "engine-service")]
impl std::fmt::Debug for super::GetEngineRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetEngineRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "engine-service")]
impl std::fmt::Debug for super::ListEnginesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListEnginesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("filter", &self.filter);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "engine-service")]
impl std::fmt::Debug for super::ListEnginesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListEnginesResponse");
        debug_struct.field("engines", &self.engines);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "engine-service")]
impl std::fmt::Debug for super::UpdateEngineRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateEngineRequest");
        debug_struct.field("engine", &self.engine);
        debug_struct.field("update_mask", &self.update_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "grounded-generation-service")]
impl std::fmt::Debug for super::GroundedGenerationContent {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GroundedGenerationContent");
        debug_struct.field("role", &self.role);
        debug_struct.field("parts", &self.parts);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "grounded-generation-service")]
impl std::fmt::Debug for super::grounded_generation_content::Part {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Part");
        debug_struct.field("data", &self.data);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "grounded-generation-service")]
impl std::fmt::Debug for super::GenerateGroundedContentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GenerateGroundedContentRequest");
        debug_struct.field("location", &self.location);
        debug_struct.field("system_instruction", &self.system_instruction);
        debug_struct.field("contents", &self.contents);
        debug_struct.field("generation_spec", &self.generation_spec);
        debug_struct.field("grounding_spec", &self.grounding_spec);
        debug_struct.field("user_labels", &self.user_labels);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "grounded-generation-service")]
impl std::fmt::Debug for super::generate_grounded_content_request::GenerationSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GenerationSpec");
        debug_struct.field("model_id", &self.model_id);
        debug_struct.field("language_code", &self.language_code);
        debug_struct.field("temperature", &self.temperature);
        debug_struct.field("top_p", &self.top_p);
        debug_struct.field("top_k", &self.top_k);
        debug_struct.field("frequency_penalty", &self.frequency_penalty);
        debug_struct.field("seed", &self.seed);
        debug_struct.field("presence_penalty", &self.presence_penalty);
        debug_struct.field("max_output_tokens", &self.max_output_tokens);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "grounded-generation-service")]
impl std::fmt::Debug for super::generate_grounded_content_request::DynamicRetrievalConfiguration {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DynamicRetrievalConfiguration");
        debug_struct.field("predictor", &self.predictor);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "grounded-generation-service")]
impl std::fmt::Debug for super::generate_grounded_content_request::dynamic_retrieval_configuration::DynamicRetrievalPredictor {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DynamicRetrievalPredictor");
        debug_struct.field("version", &self.version);
        debug_struct.field("threshold", &self.threshold);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "grounded-generation-service")]
impl std::fmt::Debug for super::generate_grounded_content_request::GroundingSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GroundingSource");
        debug_struct.field("source", &self.source);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "grounded-generation-service")]
impl std::fmt::Debug for super::generate_grounded_content_request::grounding_source::InlineSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("InlineSource");
        debug_struct.field("grounding_facts", &self.grounding_facts);
        debug_struct.field("attributes", &self.attributes);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "grounded-generation-service")]
impl std::fmt::Debug for super::generate_grounded_content_request::grounding_source::SearchSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SearchSource");
        debug_struct.field("serving_config", &self.serving_config);
        debug_struct.field("max_result_count", &self.max_result_count);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("safe_search", &self.safe_search);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "grounded-generation-service")]
impl std::fmt::Debug
    for super::generate_grounded_content_request::grounding_source::GoogleSearchSource
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GoogleSearchSource");
        debug_struct.field("dynamic_retrieval_config", &self.dynamic_retrieval_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "grounded-generation-service")]
impl std::fmt::Debug
    for super::generate_grounded_content_request::grounding_source::EnterpriseWebRetrievalSource
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("EnterpriseWebRetrievalSource");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "grounded-generation-service")]
impl std::fmt::Debug for super::generate_grounded_content_request::GroundingSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GroundingSpec");
        debug_struct.field("grounding_sources", &self.grounding_sources);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "grounded-generation-service")]
impl std::fmt::Debug for super::GenerateGroundedContentResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GenerateGroundedContentResponse");
        debug_struct.field("candidates", &self.candidates);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "grounded-generation-service")]
impl std::fmt::Debug for super::generate_grounded_content_response::Candidate {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Candidate");
        debug_struct.field("index", &self.index);
        debug_struct.field("content", &self.content);
        debug_struct.field("grounding_score", &self.grounding_score);
        debug_struct.field("grounding_metadata", &self.grounding_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "grounded-generation-service")]
impl std::fmt::Debug for super::generate_grounded_content_response::candidate::GroundingMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GroundingMetadata");
        debug_struct.field("retrieval_metadata", &self.retrieval_metadata);
        debug_struct.field("support_chunks", &self.support_chunks);
        debug_struct.field("web_search_queries", &self.web_search_queries);
        debug_struct.field("search_entry_point", &self.search_entry_point);
        debug_struct.field("grounding_support", &self.grounding_support);
        debug_struct.field("images", &self.images);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "grounded-generation-service")]
impl std::fmt::Debug
    for super::generate_grounded_content_response::candidate::grounding_metadata::RetrievalMetadata
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RetrievalMetadata");
        debug_struct.field("source", &self.source);
        debug_struct.field(
            "dynamic_retrieval_metadata",
            &self.dynamic_retrieval_metadata,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "grounded-generation-service")]
impl std::fmt::Debug for super::generate_grounded_content_response::candidate::grounding_metadata::DynamicRetrievalMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DynamicRetrievalMetadata");
        debug_struct.field("predictor_metadata", &self.predictor_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "grounded-generation-service")]
impl std::fmt::Debug for super::generate_grounded_content_response::candidate::grounding_metadata::DynamicRetrievalPredictorMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DynamicRetrievalPredictorMetadata");
        debug_struct.field("version", &self.version);
        debug_struct.field("prediction", &self.prediction);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "grounded-generation-service")]
impl std::fmt::Debug
    for super::generate_grounded_content_response::candidate::grounding_metadata::SearchEntryPoint
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SearchEntryPoint");
        debug_struct.field("rendered_content", &self.rendered_content);
        debug_struct.field("sdk_blob", &self.sdk_blob);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "grounded-generation-service")]
impl std::fmt::Debug
    for super::generate_grounded_content_response::candidate::grounding_metadata::GroundingSupport
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GroundingSupport");
        debug_struct.field("claim_text", &self.claim_text);
        debug_struct.field("support_chunk_indices", &self.support_chunk_indices);
        debug_struct.field("support_score", &self.support_score);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "grounded-generation-service")]
impl std::fmt::Debug
    for super::generate_grounded_content_response::candidate::grounding_metadata::ImageMetadata
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ImageMetadata");
        debug_struct.field("image", &self.image);
        debug_struct.field("thumbnail", &self.thumbnail);
        debug_struct.field("source", &self.source);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "grounded-generation-service")]
impl std::fmt::Debug for super::generate_grounded_content_response::candidate::grounding_metadata::image_metadata::WebsiteInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("WebsiteInfo");
        debug_struct.field("uri", &self.uri);
        debug_struct.field("title", &self.title);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "grounded-generation-service")]
impl std::fmt::Debug for super::generate_grounded_content_response::candidate::grounding_metadata::image_metadata::Image {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Image");
        debug_struct.field("uri", &self.uri);
        debug_struct.field("width", &self.width);
        debug_struct.field("height", &self.height);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "grounded-generation-service")]
impl std::fmt::Debug for super::CheckGroundingSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CheckGroundingSpec");
        debug_struct.field("citation_threshold", &self.citation_threshold);
        debug_struct.field("enable_claim_level_score", &self.enable_claim_level_score);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "grounded-generation-service")]
impl std::fmt::Debug for super::CheckGroundingRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CheckGroundingRequest");
        debug_struct.field("grounding_config", &self.grounding_config);
        debug_struct.field("answer_candidate", &self.answer_candidate);
        debug_struct.field("facts", &self.facts);
        debug_struct.field("grounding_spec", &self.grounding_spec);
        debug_struct.field("user_labels", &self.user_labels);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "grounded-generation-service")]
impl std::fmt::Debug for super::CheckGroundingResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CheckGroundingResponse");
        debug_struct.field("support_score", &self.support_score);
        debug_struct.field("cited_chunks", &self.cited_chunks);
        debug_struct.field("cited_facts", &self.cited_facts);
        debug_struct.field("claims", &self.claims);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "grounded-generation-service")]
impl std::fmt::Debug for super::check_grounding_response::CheckGroundingFactChunk {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CheckGroundingFactChunk");
        debug_struct.field("chunk_text", &self.chunk_text);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "grounded-generation-service")]
impl std::fmt::Debug for super::check_grounding_response::Claim {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Claim");
        debug_struct.field("start_pos", &self.start_pos);
        debug_struct.field("end_pos", &self.end_pos);
        debug_struct.field("claim_text", &self.claim_text);
        debug_struct.field("citation_indices", &self.citation_indices);
        debug_struct.field("grounding_check_required", &self.grounding_check_required);
        debug_struct.field("score", &self.score);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "grounded-generation-service")]
impl std::fmt::Debug for super::GroundingFact {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GroundingFact");
        debug_struct.field("fact_text", &self.fact_text);
        debug_struct.field("attributes", &self.attributes);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "grounded-generation-service")]
impl std::fmt::Debug for super::FactChunk {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FactChunk");
        debug_struct.field("chunk_text", &self.chunk_text);
        debug_struct.field("source", &self.source);
        debug_struct.field("index", &self.index);
        debug_struct.field("source_metadata", &self.source_metadata);
        debug_struct.field("uri", &self.uri);
        debug_struct.field("title", &self.title);
        debug_struct.field("domain", &self.domain);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "identity-mapping-store-service")]
impl std::fmt::Debug for super::IdentityMappingStore {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("IdentityMappingStore");
        debug_struct.field("name", &self.name);
        debug_struct.field("kms_key_name", &self.kms_key_name);
        debug_struct.field("cmek_config", &self.cmek_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "identity-mapping-store-service")]
impl std::fmt::Debug for super::IdentityMappingEntry {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("IdentityMappingEntry");
        debug_struct.field("external_identity", &self.external_identity);
        debug_struct.field("identity_provider_id", &self.identity_provider_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "identity-mapping-store-service")]
impl std::fmt::Debug for super::CreateIdentityMappingStoreRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateIdentityMappingStoreRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("identity_mapping_store_id", &self.identity_mapping_store_id);
        debug_struct.field("identity_mapping_store", &self.identity_mapping_store);
        debug_struct.field("cmek_options", &self.cmek_options);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "identity-mapping-store-service")]
impl std::fmt::Debug for super::GetIdentityMappingStoreRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetIdentityMappingStoreRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "identity-mapping-store-service")]
impl std::fmt::Debug for super::DeleteIdentityMappingStoreRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteIdentityMappingStoreRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "identity-mapping-store-service")]
impl std::fmt::Debug for super::ImportIdentityMappingsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ImportIdentityMappingsRequest");
        debug_struct.field("identity_mapping_store", &self.identity_mapping_store);
        debug_struct.field("source", &self.source);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "identity-mapping-store-service")]
impl std::fmt::Debug for super::import_identity_mappings_request::InlineSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("InlineSource");
        debug_struct.field("identity_mapping_entries", &self.identity_mapping_entries);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "identity-mapping-store-service")]
impl std::fmt::Debug for super::ImportIdentityMappingsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ImportIdentityMappingsResponse");
        debug_struct.field("error_samples", &self.error_samples);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "identity-mapping-store-service")]
impl std::fmt::Debug for super::PurgeIdentityMappingsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PurgeIdentityMappingsRequest");
        debug_struct.field("identity_mapping_store", &self.identity_mapping_store);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("force", &self.force);
        debug_struct.field("source", &self.source);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "identity-mapping-store-service")]
impl std::fmt::Debug for super::purge_identity_mappings_request::InlineSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("InlineSource");
        debug_struct.field("identity_mapping_entries", &self.identity_mapping_entries);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "identity-mapping-store-service")]
impl std::fmt::Debug for super::ListIdentityMappingsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListIdentityMappingsRequest");
        debug_struct.field("identity_mapping_store", &self.identity_mapping_store);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "identity-mapping-store-service")]
impl std::fmt::Debug for super::ListIdentityMappingsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListIdentityMappingsResponse");
        debug_struct.field("identity_mapping_entries", &self.identity_mapping_entries);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "identity-mapping-store-service")]
impl std::fmt::Debug for super::ListIdentityMappingStoresRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListIdentityMappingStoresRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "identity-mapping-store-service")]
impl std::fmt::Debug for super::ListIdentityMappingStoresResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListIdentityMappingStoresResponse");
        debug_struct.field("identity_mapping_stores", &self.identity_mapping_stores);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "identity-mapping-store-service")]
impl std::fmt::Debug for super::IdentityMappingEntryOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("IdentityMappingEntryOperationMetadata");
        debug_struct.field("success_count", &self.success_count);
        debug_struct.field("failure_count", &self.failure_count);
        debug_struct.field("total_count", &self.total_count);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "identity-mapping-store-service")]
impl std::fmt::Debug for super::DeleteIdentityMappingStoreMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteIdentityMappingStoreMetadata");
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "completion-service",
    feature = "document-service",
    feature = "user-event-service",
))]
impl std::fmt::Debug for super::GcsSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GcsSource");
        debug_struct.field("input_uris", &self.input_uris);
        debug_struct.field("data_schema", &self.data_schema);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "completion-service",
    feature = "document-service",
    feature = "user-event-service",
))]
impl std::fmt::Debug for super::BigQuerySource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BigQuerySource");
        debug_struct.field("project_id", &self.project_id);
        debug_struct.field("dataset_id", &self.dataset_id);
        debug_struct.field("table_id", &self.table_id);
        debug_struct.field("gcs_staging_dir", &self.gcs_staging_dir);
        debug_struct.field("data_schema", &self.data_schema);
        debug_struct.field("partition", &self.partition);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "document-service")]
impl std::fmt::Debug for super::SpannerSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SpannerSource");
        debug_struct.field("project_id", &self.project_id);
        debug_struct.field("instance_id", &self.instance_id);
        debug_struct.field("database_id", &self.database_id);
        debug_struct.field("table_id", &self.table_id);
        debug_struct.field("enable_data_boost", &self.enable_data_boost);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "document-service")]
impl std::fmt::Debug for super::BigtableOptions {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BigtableOptions");
        debug_struct.field("key_field_name", &self.key_field_name);
        debug_struct.field("families", &self.families);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "document-service")]
impl std::fmt::Debug for super::bigtable_options::BigtableColumnFamily {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BigtableColumnFamily");
        debug_struct.field("field_name", &self.field_name);
        debug_struct.field("encoding", &self.encoding);
        debug_struct.field("r#type", &self.r#type);
        debug_struct.field("columns", &self.columns);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "document-service")]
impl std::fmt::Debug for super::bigtable_options::BigtableColumn {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BigtableColumn");
        debug_struct.field("qualifier", &self.qualifier);
        debug_struct.field("field_name", &self.field_name);
        debug_struct.field("encoding", &self.encoding);
        debug_struct.field("r#type", &self.r#type);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "document-service")]
impl std::fmt::Debug for super::BigtableSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BigtableSource");
        debug_struct.field("project_id", &self.project_id);
        debug_struct.field("instance_id", &self.instance_id);
        debug_struct.field("table_id", &self.table_id);
        debug_struct.field("bigtable_options", &self.bigtable_options);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "document-service")]
impl std::fmt::Debug for super::FhirStoreSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FhirStoreSource");
        debug_struct.field("fhir_store", &self.fhir_store);
        debug_struct.field("gcs_staging_dir", &self.gcs_staging_dir);
        debug_struct.field("resource_types", &self.resource_types);
        debug_struct.field(
            "update_from_latest_predefined_schema",
            &self.update_from_latest_predefined_schema,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "document-service")]
impl std::fmt::Debug for super::CloudSqlSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CloudSqlSource");
        debug_struct.field("project_id", &self.project_id);
        debug_struct.field("instance_id", &self.instance_id);
        debug_struct.field("database_id", &self.database_id);
        debug_struct.field("table_id", &self.table_id);
        debug_struct.field("gcs_staging_dir", &self.gcs_staging_dir);
        debug_struct.field("offload", &self.offload);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "document-service")]
impl std::fmt::Debug for super::AlloyDbSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AlloyDbSource");
        debug_struct.field("project_id", &self.project_id);
        debug_struct.field("location_id", &self.location_id);
        debug_struct.field("cluster_id", &self.cluster_id);
        debug_struct.field("database_id", &self.database_id);
        debug_struct.field("table_id", &self.table_id);
        debug_struct.field("gcs_staging_dir", &self.gcs_staging_dir);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "document-service")]
impl std::fmt::Debug for super::FirestoreSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FirestoreSource");
        debug_struct.field("project_id", &self.project_id);
        debug_struct.field("database_id", &self.database_id);
        debug_struct.field("collection_id", &self.collection_id);
        debug_struct.field("gcs_staging_dir", &self.gcs_staging_dir);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "completion-service",
    feature = "document-service",
    feature = "search-tuning-service",
    feature = "user-event-service",
))]
impl std::fmt::Debug for super::ImportErrorConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ImportErrorConfig");
        debug_struct.field("destination", &self.destination);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "user-event-service")]
impl std::fmt::Debug for super::ImportUserEventsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ImportUserEventsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("error_config", &self.error_config);
        debug_struct.field("source", &self.source);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "user-event-service")]
impl std::fmt::Debug for super::import_user_events_request::InlineSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("InlineSource");
        debug_struct.field("user_events", &self.user_events);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "user-event-service")]
impl std::fmt::Debug for super::ImportUserEventsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ImportUserEventsResponse");
        debug_struct.field("error_samples", &self.error_samples);
        debug_struct.field("error_config", &self.error_config);
        debug_struct.field("joined_events_count", &self.joined_events_count);
        debug_struct.field("unjoined_events_count", &self.unjoined_events_count);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "user-event-service")]
impl std::fmt::Debug for super::ImportUserEventsMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ImportUserEventsMetadata");
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("success_count", &self.success_count);
        debug_struct.field("failure_count", &self.failure_count);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "document-service")]
impl std::fmt::Debug for super::ImportDocumentsMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ImportDocumentsMetadata");
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("success_count", &self.success_count);
        debug_struct.field("failure_count", &self.failure_count);
        debug_struct.field("total_count", &self.total_count);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "document-service")]
impl std::fmt::Debug for super::ImportDocumentsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ImportDocumentsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("error_config", &self.error_config);
        debug_struct.field("reconciliation_mode", &self.reconciliation_mode);
        debug_struct.field("update_mask", &self.update_mask);
        debug_struct.field("auto_generate_ids", &self.auto_generate_ids);
        debug_struct.field("id_field", &self.id_field);
        debug_struct.field("force_refresh_content", &self.force_refresh_content);
        debug_struct.field("source", &self.source);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "document-service")]
impl std::fmt::Debug for super::import_documents_request::InlineSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("InlineSource");
        debug_struct.field("documents", &self.documents);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "document-service")]
impl std::fmt::Debug for super::ImportDocumentsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ImportDocumentsResponse");
        debug_struct.field("error_samples", &self.error_samples);
        debug_struct.field("error_config", &self.error_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "completion-service")]
impl std::fmt::Debug for super::ImportSuggestionDenyListEntriesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ImportSuggestionDenyListEntriesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("source", &self.source);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "completion-service")]
impl std::fmt::Debug for super::import_suggestion_deny_list_entries_request::InlineSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("InlineSource");
        debug_struct.field("entries", &self.entries);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "completion-service")]
impl std::fmt::Debug for super::ImportSuggestionDenyListEntriesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ImportSuggestionDenyListEntriesResponse");
        debug_struct.field("error_samples", &self.error_samples);
        debug_struct.field("imported_entries_count", &self.imported_entries_count);
        debug_struct.field("failed_entries_count", &self.failed_entries_count);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "completion-service")]
impl std::fmt::Debug for super::ImportSuggestionDenyListEntriesMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ImportSuggestionDenyListEntriesMetadata");
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "completion-service")]
impl std::fmt::Debug for super::ImportCompletionSuggestionsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ImportCompletionSuggestionsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("error_config", &self.error_config);
        debug_struct.field("source", &self.source);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "completion-service")]
impl std::fmt::Debug for super::import_completion_suggestions_request::InlineSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("InlineSource");
        debug_struct.field("suggestions", &self.suggestions);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "completion-service")]
impl std::fmt::Debug for super::ImportCompletionSuggestionsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ImportCompletionSuggestionsResponse");
        debug_struct.field("error_samples", &self.error_samples);
        debug_struct.field("error_config", &self.error_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "completion-service")]
impl std::fmt::Debug for super::ImportCompletionSuggestionsMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ImportCompletionSuggestionsMetadata");
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("success_count", &self.success_count);
        debug_struct.field("failure_count", &self.failure_count);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "project-service")]
impl std::fmt::Debug for super::Project {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Project");
        debug_struct.field("name", &self.name);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("provision_completion_time", &self.provision_completion_time);
        debug_struct.field("service_terms_map", &self.service_terms_map);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "project-service")]
impl std::fmt::Debug for super::project::ServiceTerms {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ServiceTerms");
        debug_struct.field("id", &self.id);
        debug_struct.field("version", &self.version);
        debug_struct.field("state", &self.state);
        debug_struct.field("accept_time", &self.accept_time);
        debug_struct.field("decline_time", &self.decline_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "project-service")]
impl std::fmt::Debug for super::ProvisionProjectRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ProvisionProjectRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("accept_data_use_terms", &self.accept_data_use_terms);
        debug_struct.field("data_use_terms_version", &self.data_use_terms_version);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "project-service")]
impl std::fmt::Debug for super::ProvisionProjectMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ProvisionProjectMetadata");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "user-event-service")]
impl std::fmt::Debug for super::PurgeUserEventsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PurgeUserEventsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("force", &self.force);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "user-event-service")]
impl std::fmt::Debug for super::PurgeUserEventsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PurgeUserEventsResponse");
        debug_struct.field("purge_count", &self.purge_count);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "user-event-service")]
impl std::fmt::Debug for super::PurgeUserEventsMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PurgeUserEventsMetadata");
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("success_count", &self.success_count);
        debug_struct.field("failure_count", &self.failure_count);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "document-service")]
impl std::fmt::Debug for super::PurgeErrorConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PurgeErrorConfig");
        debug_struct.field("destination", &self.destination);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "document-service")]
impl std::fmt::Debug for super::PurgeDocumentsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PurgeDocumentsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("error_config", &self.error_config);
        debug_struct.field("force", &self.force);
        debug_struct.field("source", &self.source);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "document-service")]
impl std::fmt::Debug for super::purge_documents_request::InlineSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("InlineSource");
        debug_struct.field("documents", &self.documents);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "document-service")]
impl std::fmt::Debug for super::PurgeDocumentsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PurgeDocumentsResponse");
        debug_struct.field("purge_count", &self.purge_count);
        debug_struct.field("purge_sample", &self.purge_sample);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "document-service")]
impl std::fmt::Debug for super::PurgeDocumentsMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PurgeDocumentsMetadata");
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("success_count", &self.success_count);
        debug_struct.field("failure_count", &self.failure_count);
        debug_struct.field("ignored_count", &self.ignored_count);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "completion-service")]
impl std::fmt::Debug for super::PurgeSuggestionDenyListEntriesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PurgeSuggestionDenyListEntriesRequest");
        debug_struct.field("parent", &self.parent);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "completion-service")]
impl std::fmt::Debug for super::PurgeSuggestionDenyListEntriesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PurgeSuggestionDenyListEntriesResponse");
        debug_struct.field("purge_count", &self.purge_count);
        debug_struct.field("error_samples", &self.error_samples);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "completion-service")]
impl std::fmt::Debug for super::PurgeSuggestionDenyListEntriesMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PurgeSuggestionDenyListEntriesMetadata");
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "completion-service")]
impl std::fmt::Debug for super::PurgeCompletionSuggestionsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PurgeCompletionSuggestionsRequest");
        debug_struct.field("parent", &self.parent);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "completion-service")]
impl std::fmt::Debug for super::PurgeCompletionSuggestionsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PurgeCompletionSuggestionsResponse");
        debug_struct.field("purge_succeeded", &self.purge_succeeded);
        debug_struct.field("error_samples", &self.error_samples);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "completion-service")]
impl std::fmt::Debug for super::PurgeCompletionSuggestionsMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PurgeCompletionSuggestionsMetadata");
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "rank-service")]
impl std::fmt::Debug for super::RankingRecord {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RankingRecord");
        debug_struct.field("id", &self.id);
        debug_struct.field("title", &self.title);
        debug_struct.field("content", &self.content);
        debug_struct.field("score", &self.score);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "rank-service")]
impl std::fmt::Debug for super::RankRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RankRequest");
        debug_struct.field("ranking_config", &self.ranking_config);
        debug_struct.field("model", &self.model);
        debug_struct.field("top_n", &self.top_n);
        debug_struct.field("query", &self.query);
        debug_struct.field("records", &self.records);
        debug_struct.field(
            "ignore_record_details_in_response",
            &self.ignore_record_details_in_response,
        );
        debug_struct.field("user_labels", &self.user_labels);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "rank-service")]
impl std::fmt::Debug for super::RankResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RankResponse");
        debug_struct.field("records", &self.records);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "recommendation-service")]
impl std::fmt::Debug for super::RecommendRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RecommendRequest");
        debug_struct.field("serving_config", &self.serving_config);
        debug_struct.field("user_event", &self.user_event);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("validate_only", &self.validate_only);
        debug_struct.field("params", &self.params);
        debug_struct.field("user_labels", &self.user_labels);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "recommendation-service")]
impl std::fmt::Debug for super::RecommendResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RecommendResponse");
        debug_struct.field("results", &self.results);
        debug_struct.field("attribution_token", &self.attribution_token);
        debug_struct.field("missing_ids", &self.missing_ids);
        debug_struct.field("validate_only", &self.validate_only);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "recommendation-service")]
impl std::fmt::Debug for super::recommend_response::RecommendationResult {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RecommendationResult");
        debug_struct.field("id", &self.id);
        debug_struct.field("document", &self.document);
        debug_struct.field("metadata", &self.metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl std::fmt::Debug for super::SafetyRating {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SafetyRating");
        debug_struct.field("category", &self.category);
        debug_struct.field("probability", &self.probability);
        debug_struct.field("probability_score", &self.probability_score);
        debug_struct.field("severity", &self.severity);
        debug_struct.field("severity_score", &self.severity_score);
        debug_struct.field("blocked", &self.blocked);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "data-store-service", feature = "schema-service",))]
impl std::fmt::Debug for super::Schema {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Schema");
        debug_struct.field("name", &self.name);
        debug_struct.field("schema", &self.schema);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "schema-service")]
impl std::fmt::Debug for super::GetSchemaRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetSchemaRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "schema-service")]
impl std::fmt::Debug for super::ListSchemasRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListSchemasRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "schema-service")]
impl std::fmt::Debug for super::ListSchemasResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListSchemasResponse");
        debug_struct.field("schemas", &self.schemas);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "schema-service")]
impl std::fmt::Debug for super::CreateSchemaRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateSchemaRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("schema", &self.schema);
        debug_struct.field("schema_id", &self.schema_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "schema-service")]
impl std::fmt::Debug for super::UpdateSchemaRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateSchemaRequest");
        debug_struct.field("schema", &self.schema);
        debug_struct.field("allow_missing", &self.allow_missing);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "schema-service")]
impl std::fmt::Debug for super::DeleteSchemaRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteSchemaRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "schema-service")]
impl std::fmt::Debug for super::CreateSchemaMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateSchemaMetadata");
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "schema-service")]
impl std::fmt::Debug for super::UpdateSchemaMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateSchemaMetadata");
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "schema-service")]
impl std::fmt::Debug for super::DeleteSchemaMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteSchemaMetadata");
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl std::fmt::Debug for super::SearchRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SearchRequest");
        debug_struct.field("serving_config", &self.serving_config);
        debug_struct.field("branch", &self.branch);
        debug_struct.field("query", &self.query);
        debug_struct.field("image_query", &self.image_query);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("offset", &self.offset);
        debug_struct.field("one_box_page_size", &self.one_box_page_size);
        debug_struct.field("data_store_specs", &self.data_store_specs);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("canonical_filter", &self.canonical_filter);
        debug_struct.field("order_by", &self.order_by);
        debug_struct.field("user_info", &self.user_info);
        debug_struct.field("language_code", &self.language_code);
        debug_struct.field("facet_specs", &self.facet_specs);
        debug_struct.field("boost_spec", &self.boost_spec);
        debug_struct.field("params", &self.params);
        debug_struct.field("query_expansion_spec", &self.query_expansion_spec);
        debug_struct.field("spell_correction_spec", &self.spell_correction_spec);
        debug_struct.field("user_pseudo_id", &self.user_pseudo_id);
        debug_struct.field("content_search_spec", &self.content_search_spec);
        debug_struct.field("safe_search", &self.safe_search);
        debug_struct.field("user_labels", &self.user_labels);
        debug_struct.field("search_as_you_type_spec", &self.search_as_you_type_spec);
        debug_struct.field("display_spec", &self.display_spec);
        debug_struct.field("session", &self.session);
        debug_struct.field("session_spec", &self.session_spec);
        debug_struct.field("relevance_threshold", &self.relevance_threshold);
        debug_struct.field("relevance_score_spec", &self.relevance_score_spec);
        debug_struct.field("ranking_expression", &self.ranking_expression);
        debug_struct.field(
            "ranking_expression_backend",
            &self.ranking_expression_backend,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl std::fmt::Debug for super::search_request::ImageQuery {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ImageQuery");
        debug_struct.field("image", &self.image);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl std::fmt::Debug for super::search_request::DataStoreSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DataStoreSpec");
        debug_struct.field("data_store", &self.data_store);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("boost_spec", &self.boost_spec);
        debug_struct.field("custom_search_operators", &self.custom_search_operators);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl std::fmt::Debug for super::search_request::FacetSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FacetSpec");
        debug_struct.field("facet_key", &self.facet_key);
        debug_struct.field("limit", &self.limit);
        debug_struct.field("excluded_filter_keys", &self.excluded_filter_keys);
        debug_struct.field("enable_dynamic_position", &self.enable_dynamic_position);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl std::fmt::Debug for super::search_request::facet_spec::FacetKey {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FacetKey");
        debug_struct.field("key", &self.key);
        debug_struct.field("intervals", &self.intervals);
        debug_struct.field("restricted_values", &self.restricted_values);
        debug_struct.field("prefixes", &self.prefixes);
        debug_struct.field("contains", &self.contains);
        debug_struct.field("case_insensitive", &self.case_insensitive);
        debug_struct.field("order_by", &self.order_by);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl std::fmt::Debug for super::search_request::BoostSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BoostSpec");
        debug_struct.field("condition_boost_specs", &self.condition_boost_specs);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl std::fmt::Debug for super::search_request::boost_spec::ConditionBoostSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ConditionBoostSpec");
        debug_struct.field("condition", &self.condition);
        debug_struct.field("boost", &self.boost);
        debug_struct.field("boost_control_spec", &self.boost_control_spec);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl std::fmt::Debug for super::search_request::boost_spec::condition_boost_spec::BoostControlSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BoostControlSpec");
        debug_struct.field("field_name", &self.field_name);
        debug_struct.field("attribute_type", &self.attribute_type);
        debug_struct.field("interpolation_type", &self.interpolation_type);
        debug_struct.field("control_points", &self.control_points);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl std::fmt::Debug
    for super::search_request::boost_spec::condition_boost_spec::boost_control_spec::ControlPoint
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ControlPoint");
        debug_struct.field("attribute_value", &self.attribute_value);
        debug_struct.field("boost_amount", &self.boost_amount);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl std::fmt::Debug for super::search_request::QueryExpansionSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("QueryExpansionSpec");
        debug_struct.field("condition", &self.condition);
        debug_struct.field("pin_unexpanded_results", &self.pin_unexpanded_results);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl std::fmt::Debug for super::search_request::SpellCorrectionSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SpellCorrectionSpec");
        debug_struct.field("mode", &self.mode);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl std::fmt::Debug for super::search_request::ContentSearchSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ContentSearchSpec");
        debug_struct.field("snippet_spec", &self.snippet_spec);
        debug_struct.field("summary_spec", &self.summary_spec);
        debug_struct.field("extractive_content_spec", &self.extractive_content_spec);
        debug_struct.field("search_result_mode", &self.search_result_mode);
        debug_struct.field("chunk_spec", &self.chunk_spec);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl std::fmt::Debug for super::search_request::content_search_spec::SnippetSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SnippetSpec");
        debug_struct.field("max_snippet_count", &self.max_snippet_count);
        debug_struct.field("reference_only", &self.reference_only);
        debug_struct.field("return_snippet", &self.return_snippet);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl std::fmt::Debug for super::search_request::content_search_spec::SummarySpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SummarySpec");
        debug_struct.field("summary_result_count", &self.summary_result_count);
        debug_struct.field("include_citations", &self.include_citations);
        debug_struct.field("ignore_adversarial_query", &self.ignore_adversarial_query);
        debug_struct.field(
            "ignore_non_summary_seeking_query",
            &self.ignore_non_summary_seeking_query,
        );
        debug_struct.field(
            "ignore_low_relevant_content",
            &self.ignore_low_relevant_content,
        );
        debug_struct.field(
            "ignore_jail_breaking_query",
            &self.ignore_jail_breaking_query,
        );
        debug_struct.field("model_prompt_spec", &self.model_prompt_spec);
        debug_struct.field("language_code", &self.language_code);
        debug_struct.field("model_spec", &self.model_spec);
        debug_struct.field("use_semantic_chunks", &self.use_semantic_chunks);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl std::fmt::Debug for super::search_request::content_search_spec::summary_spec::ModelPromptSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ModelPromptSpec");
        debug_struct.field("preamble", &self.preamble);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl std::fmt::Debug for super::search_request::content_search_spec::summary_spec::ModelSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ModelSpec");
        debug_struct.field("version", &self.version);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl std::fmt::Debug for super::search_request::content_search_spec::ExtractiveContentSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExtractiveContentSpec");
        debug_struct.field(
            "max_extractive_answer_count",
            &self.max_extractive_answer_count,
        );
        debug_struct.field(
            "max_extractive_segment_count",
            &self.max_extractive_segment_count,
        );
        debug_struct.field(
            "return_extractive_segment_score",
            &self.return_extractive_segment_score,
        );
        debug_struct.field("num_previous_segments", &self.num_previous_segments);
        debug_struct.field("num_next_segments", &self.num_next_segments);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl std::fmt::Debug for super::search_request::content_search_spec::ChunkSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ChunkSpec");
        debug_struct.field("num_previous_chunks", &self.num_previous_chunks);
        debug_struct.field("num_next_chunks", &self.num_next_chunks);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl std::fmt::Debug for super::search_request::SearchAsYouTypeSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SearchAsYouTypeSpec");
        debug_struct.field("condition", &self.condition);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl std::fmt::Debug for super::search_request::DisplaySpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DisplaySpec");
        debug_struct.field(
            "match_highlighting_condition",
            &self.match_highlighting_condition,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl std::fmt::Debug for super::search_request::SessionSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SessionSpec");
        debug_struct.field("query_id", &self.query_id);
        debug_struct.field(
            "search_result_persistence_count",
            &self.search_result_persistence_count,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "search-service",
    feature = "serving-config-service",
))]
impl std::fmt::Debug for super::search_request::RelevanceScoreSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RelevanceScoreSpec");
        debug_struct.field("return_relevance_score", &self.return_relevance_score);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
impl std::fmt::Debug for super::SearchResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SearchResponse");
        debug_struct.field("results", &self.results);
        debug_struct.field("facets", &self.facets);
        debug_struct.field("total_size", &self.total_size);
        debug_struct.field("attribution_token", &self.attribution_token);
        debug_struct.field("redirect_uri", &self.redirect_uri);
        debug_struct.field("next_page_token", &self.next_page_token);
        debug_struct.field("corrected_query", &self.corrected_query);
        debug_struct.field("summary", &self.summary);
        debug_struct.field("query_expansion_info", &self.query_expansion_info);
        debug_struct.field("session_info", &self.session_info);
        debug_struct.field("search_link_promotions", &self.search_link_promotions);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
impl std::fmt::Debug for super::search_response::SearchResult {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SearchResult");
        debug_struct.field("id", &self.id);
        debug_struct.field("document", &self.document);
        debug_struct.field("chunk", &self.chunk);
        debug_struct.field("model_scores", &self.model_scores);
        debug_struct.field("rank_signals", &self.rank_signals);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
impl std::fmt::Debug for super::search_response::search_result::RankSignals {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RankSignals");
        debug_struct.field("keyword_similarity_score", &self.keyword_similarity_score);
        debug_struct.field("relevance_score", &self.relevance_score);
        debug_struct.field("semantic_similarity_score", &self.semantic_similarity_score);
        debug_struct.field("pctr_rank", &self.pctr_rank);
        debug_struct.field("topicality_rank", &self.topicality_rank);
        debug_struct.field("document_age", &self.document_age);
        debug_struct.field("boosting_factor", &self.boosting_factor);
        debug_struct.field("default_rank", &self.default_rank);
        debug_struct.field("custom_signals", &self.custom_signals);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
impl std::fmt::Debug for super::search_response::search_result::rank_signals::CustomSignal {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CustomSignal");
        debug_struct.field("name", &self.name);
        debug_struct.field("value", &self.value);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
impl std::fmt::Debug for super::search_response::Facet {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Facet");
        debug_struct.field("key", &self.key);
        debug_struct.field("values", &self.values);
        debug_struct.field("dynamic_facet", &self.dynamic_facet);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
impl std::fmt::Debug for super::search_response::facet::FacetValue {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FacetValue");
        debug_struct.field("count", &self.count);
        debug_struct.field("facet_value", &self.facet_value);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
impl std::fmt::Debug for super::search_response::Summary {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Summary");
        debug_struct.field("summary_text", &self.summary_text);
        debug_struct.field("summary_skipped_reasons", &self.summary_skipped_reasons);
        debug_struct.field("safety_attributes", &self.safety_attributes);
        debug_struct.field("summary_with_metadata", &self.summary_with_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
impl std::fmt::Debug for super::search_response::summary::SafetyAttributes {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SafetyAttributes");
        debug_struct.field("categories", &self.categories);
        debug_struct.field("scores", &self.scores);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
impl std::fmt::Debug for super::search_response::summary::CitationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CitationMetadata");
        debug_struct.field("citations", &self.citations);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
impl std::fmt::Debug for super::search_response::summary::Citation {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Citation");
        debug_struct.field("start_index", &self.start_index);
        debug_struct.field("end_index", &self.end_index);
        debug_struct.field("sources", &self.sources);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
impl std::fmt::Debug for super::search_response::summary::CitationSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CitationSource");
        debug_struct.field("reference_index", &self.reference_index);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
impl std::fmt::Debug for super::search_response::summary::Reference {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Reference");
        debug_struct.field("title", &self.title);
        debug_struct.field("document", &self.document);
        debug_struct.field("uri", &self.uri);
        debug_struct.field("chunk_contents", &self.chunk_contents);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
impl std::fmt::Debug for super::search_response::summary::reference::ChunkContent {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ChunkContent");
        debug_struct.field("content", &self.content);
        debug_struct.field("page_identifier", &self.page_identifier);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
impl std::fmt::Debug for super::search_response::summary::SummaryWithMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SummaryWithMetadata");
        debug_struct.field("summary", &self.summary);
        debug_struct.field("citation_metadata", &self.citation_metadata);
        debug_struct.field("references", &self.references);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
impl std::fmt::Debug for super::search_response::QueryExpansionInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("QueryExpansionInfo");
        debug_struct.field("expanded_query", &self.expanded_query);
        debug_struct.field("pinned_result_count", &self.pinned_result_count);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
impl std::fmt::Debug for super::search_response::SessionInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SessionInfo");
        debug_struct.field("name", &self.name);
        debug_struct.field("query_id", &self.query_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "search-tuning-service")]
impl std::fmt::Debug for super::ListCustomModelsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListCustomModelsRequest");
        debug_struct.field("data_store", &self.data_store);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "search-tuning-service")]
impl std::fmt::Debug for super::ListCustomModelsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListCustomModelsResponse");
        debug_struct.field("models", &self.models);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "search-tuning-service")]
impl std::fmt::Debug for super::TrainCustomModelRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TrainCustomModelRequest");
        debug_struct.field("data_store", &self.data_store);
        debug_struct.field("model_type", &self.model_type);
        debug_struct.field("error_config", &self.error_config);
        debug_struct.field("model_id", &self.model_id);
        debug_struct.field("training_input", &self.training_input);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "search-tuning-service")]
impl std::fmt::Debug for super::train_custom_model_request::GcsTrainingInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GcsTrainingInput");
        debug_struct.field("corpus_data_path", &self.corpus_data_path);
        debug_struct.field("query_data_path", &self.query_data_path);
        debug_struct.field("train_data_path", &self.train_data_path);
        debug_struct.field("test_data_path", &self.test_data_path);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "search-tuning-service")]
impl std::fmt::Debug for super::TrainCustomModelResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TrainCustomModelResponse");
        debug_struct.field("error_samples", &self.error_samples);
        debug_struct.field("error_config", &self.error_config);
        debug_struct.field("model_status", &self.model_status);
        debug_struct.field("metrics", &self.metrics);
        debug_struct.field("model_name", &self.model_name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "search-tuning-service")]
impl std::fmt::Debug for super::TrainCustomModelMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TrainCustomModelMetadata");
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "serving-config-service")]
impl std::fmt::Debug for super::ServingConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ServingConfig");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("solution_type", &self.solution_type);
        debug_struct.field("model_id", &self.model_id);
        debug_struct.field("diversity_level", &self.diversity_level);
        debug_struct.field("ranking_expression", &self.ranking_expression);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("filter_control_ids", &self.filter_control_ids);
        debug_struct.field("boost_control_ids", &self.boost_control_ids);
        debug_struct.field("redirect_control_ids", &self.redirect_control_ids);
        debug_struct.field("synonyms_control_ids", &self.synonyms_control_ids);
        debug_struct.field(
            "oneway_synonyms_control_ids",
            &self.oneway_synonyms_control_ids,
        );
        debug_struct.field("dissociate_control_ids", &self.dissociate_control_ids);
        debug_struct.field("replacement_control_ids", &self.replacement_control_ids);
        debug_struct.field("ignore_control_ids", &self.ignore_control_ids);
        debug_struct.field("promote_control_ids", &self.promote_control_ids);
        debug_struct.field("vertical_config", &self.vertical_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "serving-config-service")]
impl std::fmt::Debug for super::serving_config::MediaConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MediaConfig");
        debug_struct.field("demotion_event_type", &self.demotion_event_type);
        debug_struct.field(
            "demote_content_watched_past_days",
            &self.demote_content_watched_past_days,
        );
        debug_struct.field(
            "content_freshness_cutoff_days",
            &self.content_freshness_cutoff_days,
        );
        debug_struct.field("demote_content_watched", &self.demote_content_watched);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "serving-config-service")]
impl std::fmt::Debug for super::serving_config::GenericConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GenericConfig");
        debug_struct.field("content_search_spec", &self.content_search_spec);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "serving-config-service")]
impl std::fmt::Debug for super::UpdateServingConfigRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateServingConfigRequest");
        debug_struct.field("serving_config", &self.serving_config);
        debug_struct.field("update_mask", &self.update_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl std::fmt::Debug for super::Session {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Session");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("state", &self.state);
        debug_struct.field("user_pseudo_id", &self.user_pseudo_id);
        debug_struct.field("turns", &self.turns);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("start_time", &self.start_time);
        debug_struct.field("end_time", &self.end_time);
        debug_struct.field("is_pinned", &self.is_pinned);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
impl std::fmt::Debug for super::session::Turn {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Turn");
        debug_struct.field("query", &self.query);
        debug_struct.field("answer", &self.answer);
        debug_struct.field("detailed_answer", &self.detailed_answer);
        debug_struct.field("detailed_assist_answer", &self.detailed_assist_answer);
        debug_struct.field("query_config", &self.query_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "assistant-service",
    feature = "conversational-search-service",
    feature = "session-service",
))]
impl std::fmt::Debug for super::Query {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Query");
        debug_struct.field("query_id", &self.query_id);
        debug_struct.field("content", &self.content);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::SiteSearchEngine {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SiteSearchEngine");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::TargetSite {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TargetSite");
        debug_struct.field("name", &self.name);
        debug_struct.field("provided_uri_pattern", &self.provided_uri_pattern);
        debug_struct.field("r#type", &self.r#type);
        debug_struct.field("exact_match", &self.exact_match);
        debug_struct.field("generated_uri_pattern", &self.generated_uri_pattern);
        debug_struct.field("root_domain_uri", &self.root_domain_uri);
        debug_struct.field("site_verification_info", &self.site_verification_info);
        debug_struct.field("indexing_status", &self.indexing_status);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("failure_reason", &self.failure_reason);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::target_site::FailureReason {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FailureReason");
        debug_struct.field("failure", &self.failure);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::target_site::failure_reason::QuotaFailure {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("QuotaFailure");
        debug_struct.field("total_required_quota", &self.total_required_quota);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::SiteVerificationInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SiteVerificationInfo");
        debug_struct.field("site_verification_state", &self.site_verification_state);
        debug_struct.field("verify_time", &self.verify_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::Sitemap {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Sitemap");
        debug_struct.field("name", &self.name);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("feed", &self.feed);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::GetSiteSearchEngineRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetSiteSearchEngineRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::CreateTargetSiteRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateTargetSiteRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("target_site", &self.target_site);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::CreateTargetSiteMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateTargetSiteMetadata");
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::BatchCreateTargetSitesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchCreateTargetSitesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("requests", &self.requests);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::GetTargetSiteRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetTargetSiteRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::UpdateTargetSiteRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateTargetSiteRequest");
        debug_struct.field("target_site", &self.target_site);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::UpdateTargetSiteMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateTargetSiteMetadata");
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::DeleteTargetSiteRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteTargetSiteRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::DeleteTargetSiteMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteTargetSiteMetadata");
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::ListTargetSitesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListTargetSitesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::ListTargetSitesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListTargetSitesResponse");
        debug_struct.field("target_sites", &self.target_sites);
        debug_struct.field("next_page_token", &self.next_page_token);
        debug_struct.field("total_size", &self.total_size);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::BatchCreateTargetSiteMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchCreateTargetSiteMetadata");
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::BatchCreateTargetSitesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchCreateTargetSitesResponse");
        debug_struct.field("target_sites", &self.target_sites);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::CreateSitemapRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateSitemapRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("sitemap", &self.sitemap);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::DeleteSitemapRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteSitemapRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::FetchSitemapsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FetchSitemapsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("matcher", &self.matcher);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::fetch_sitemaps_request::UrisMatcher {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UrisMatcher");
        debug_struct.field("uris", &self.uris);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::fetch_sitemaps_request::Matcher {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Matcher");
        debug_struct.field("matcher", &self.matcher);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::CreateSitemapMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateSitemapMetadata");
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::DeleteSitemapMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteSitemapMetadata");
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::FetchSitemapsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FetchSitemapsResponse");
        debug_struct.field("sitemaps_metadata", &self.sitemaps_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::fetch_sitemaps_response::SitemapMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SitemapMetadata");
        debug_struct.field("sitemap", &self.sitemap);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::EnableAdvancedSiteSearchRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("EnableAdvancedSiteSearchRequest");
        debug_struct.field("site_search_engine", &self.site_search_engine);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::EnableAdvancedSiteSearchResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("EnableAdvancedSiteSearchResponse");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::EnableAdvancedSiteSearchMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("EnableAdvancedSiteSearchMetadata");
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::DisableAdvancedSiteSearchRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DisableAdvancedSiteSearchRequest");
        debug_struct.field("site_search_engine", &self.site_search_engine);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::DisableAdvancedSiteSearchResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DisableAdvancedSiteSearchResponse");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::DisableAdvancedSiteSearchMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DisableAdvancedSiteSearchMetadata");
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::RecrawlUrisRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RecrawlUrisRequest");
        debug_struct.field("site_search_engine", &self.site_search_engine);
        debug_struct.field("uris", &self.uris);
        debug_struct.field("site_credential", &self.site_credential);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::RecrawlUrisResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RecrawlUrisResponse");
        debug_struct.field("failure_samples", &self.failure_samples);
        debug_struct.field("failed_uris", &self.failed_uris);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::recrawl_uris_response::FailureInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FailureInfo");
        debug_struct.field("uri", &self.uri);
        debug_struct.field("failure_reasons", &self.failure_reasons);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::recrawl_uris_response::failure_info::FailureReason {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FailureReason");
        debug_struct.field("corpus_type", &self.corpus_type);
        debug_struct.field("error_message", &self.error_message);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::RecrawlUrisMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RecrawlUrisMetadata");
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("invalid_uris", &self.invalid_uris);
        debug_struct.field("invalid_uris_count", &self.invalid_uris_count);
        debug_struct.field("noindex_uris", &self.noindex_uris);
        debug_struct.field("noindex_uris_count", &self.noindex_uris_count);
        debug_struct.field(
            "uris_not_matching_target_sites",
            &self.uris_not_matching_target_sites,
        );
        debug_struct.field(
            "uris_not_matching_target_sites_count",
            &self.uris_not_matching_target_sites_count,
        );
        debug_struct.field("valid_uris_count", &self.valid_uris_count);
        debug_struct.field("success_count", &self.success_count);
        debug_struct.field("pending_count", &self.pending_count);
        debug_struct.field("quota_exceeded_count", &self.quota_exceeded_count);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::BatchVerifyTargetSitesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchVerifyTargetSitesRequest");
        debug_struct.field("parent", &self.parent);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::BatchVerifyTargetSitesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchVerifyTargetSitesResponse");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::BatchVerifyTargetSitesMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchVerifyTargetSitesMetadata");
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::FetchDomainVerificationStatusRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FetchDomainVerificationStatusRequest");
        debug_struct.field("site_search_engine", &self.site_search_engine);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "site-search-engine-service")]
impl std::fmt::Debug for super::FetchDomainVerificationStatusResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FetchDomainVerificationStatusResponse");
        debug_struct.field("target_sites", &self.target_sites);
        debug_struct.field("next_page_token", &self.next_page_token);
        debug_struct.field("total_size", &self.total_size);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "recommendation-service", feature = "user-event-service",))]
impl std::fmt::Debug for super::UserEvent {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UserEvent");
        debug_struct.field("event_type", &self.event_type);
        debug_struct.field("conversion_type", &self.conversion_type);
        debug_struct.field("user_pseudo_id", &self.user_pseudo_id);
        debug_struct.field("engine", &self.engine);
        debug_struct.field("data_store", &self.data_store);
        debug_struct.field("event_time", &self.event_time);
        debug_struct.field("user_info", &self.user_info);
        debug_struct.field("direct_user_request", &self.direct_user_request);
        debug_struct.field("session_id", &self.session_id);
        debug_struct.field("page_info", &self.page_info);
        debug_struct.field("attribution_token", &self.attribution_token);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("documents", &self.documents);
        debug_struct.field("panel", &self.panel);
        debug_struct.field("search_info", &self.search_info);
        debug_struct.field("completion_info", &self.completion_info);
        debug_struct.field("transaction_info", &self.transaction_info);
        debug_struct.field("tag_ids", &self.tag_ids);
        debug_struct.field("promotion_ids", &self.promotion_ids);
        debug_struct.field("attributes", &self.attributes);
        debug_struct.field("media_info", &self.media_info);
        debug_struct.field("panels", &self.panels);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "recommendation-service", feature = "user-event-service",))]
impl std::fmt::Debug for super::PageInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PageInfo");
        debug_struct.field("pageview_id", &self.pageview_id);
        debug_struct.field("page_category", &self.page_category);
        debug_struct.field("uri", &self.uri);
        debug_struct.field("referrer_uri", &self.referrer_uri);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "recommendation-service", feature = "user-event-service",))]
impl std::fmt::Debug for super::SearchInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SearchInfo");
        debug_struct.field("search_query", &self.search_query);
        debug_struct.field("order_by", &self.order_by);
        debug_struct.field("offset", &self.offset);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "recommendation-service", feature = "user-event-service",))]
impl std::fmt::Debug for super::CompletionInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CompletionInfo");
        debug_struct.field("selected_suggestion", &self.selected_suggestion);
        debug_struct.field("selected_position", &self.selected_position);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "recommendation-service", feature = "user-event-service",))]
impl std::fmt::Debug for super::TransactionInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TransactionInfo");
        debug_struct.field("value", &self.value);
        debug_struct.field("currency", &self.currency);
        debug_struct.field("transaction_id", &self.transaction_id);
        debug_struct.field("tax", &self.tax);
        debug_struct.field("cost", &self.cost);
        debug_struct.field("discount_value", &self.discount_value);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "recommendation-service", feature = "user-event-service",))]
impl std::fmt::Debug for super::DocumentInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DocumentInfo");
        debug_struct.field("quantity", &self.quantity);
        debug_struct.field("promotion_ids", &self.promotion_ids);
        debug_struct.field("joined", &self.joined);
        debug_struct.field("conversion_value", &self.conversion_value);
        debug_struct.field("document_descriptor", &self.document_descriptor);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "recommendation-service", feature = "user-event-service",))]
impl std::fmt::Debug for super::PanelInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PanelInfo");
        debug_struct.field("panel_id", &self.panel_id);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("panel_position", &self.panel_position);
        debug_struct.field("total_panels", &self.total_panels);
        debug_struct.field("documents", &self.documents);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "recommendation-service", feature = "user-event-service",))]
impl std::fmt::Debug for super::MediaInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MediaInfo");
        debug_struct.field("media_progress_duration", &self.media_progress_duration);
        debug_struct.field("media_progress_percentage", &self.media_progress_percentage);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "user-event-service")]
impl std::fmt::Debug for super::WriteUserEventRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("WriteUserEventRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("user_event", &self.user_event);
        debug_struct.field("write_async", &self.write_async);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "user-event-service")]
impl std::fmt::Debug for super::CollectUserEventRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CollectUserEventRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("user_event", &self.user_event);
        debug_struct.field("uri", &self.uri);
        debug_struct.field("ets", &self.ets);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "user-license-service")]
impl std::fmt::Debug for super::UserLicense {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UserLicense");
        debug_struct.field("user_principal", &self.user_principal);
        debug_struct.field("user_profile", &self.user_profile);
        debug_struct.field("license_assignment_state", &self.license_assignment_state);
        debug_struct.field("license_config", &self.license_config);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("last_login_time", &self.last_login_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "user-license-service")]
impl std::fmt::Debug for super::ListUserLicensesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListUserLicensesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("filter", &self.filter);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "user-license-service")]
impl std::fmt::Debug for super::ListUserLicensesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListUserLicensesResponse");
        debug_struct.field("user_licenses", &self.user_licenses);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "user-license-service")]
impl std::fmt::Debug for super::BatchUpdateUserLicensesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchUpdateUserLicensesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field(
            "delete_unassigned_user_licenses",
            &self.delete_unassigned_user_licenses,
        );
        debug_struct.field("source", &self.source);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "user-license-service")]
impl std::fmt::Debug for super::batch_update_user_licenses_request::InlineSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("InlineSource");
        debug_struct.field("user_licenses", &self.user_licenses);
        debug_struct.field("update_mask", &self.update_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "user-license-service")]
impl std::fmt::Debug for super::BatchUpdateUserLicensesMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchUpdateUserLicensesMetadata");
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("success_count", &self.success_count);
        debug_struct.field("failure_count", &self.failure_count);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "user-license-service")]
impl std::fmt::Debug for super::BatchUpdateUserLicensesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchUpdateUserLicensesResponse");
        debug_struct.field("user_licenses", &self.user_licenses);
        debug_struct.field("error_samples", &self.error_samples);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}