// 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",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::Answer {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
__state,
__answer_text,
__grounding_score,
__citations,
__grounding_supports,
__references,
__related_questions,
__steps,
__query_understanding_info,
__answer_skipped_reasons,
__create_time,
__complete_time,
__safety_ratings,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Answer")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
"state" => Ok(__FieldTag::__state),
"answerText" => Ok(__FieldTag::__answer_text),
"answer_text" => Ok(__FieldTag::__answer_text),
"groundingScore" => Ok(__FieldTag::__grounding_score),
"grounding_score" => Ok(__FieldTag::__grounding_score),
"citations" => Ok(__FieldTag::__citations),
"groundingSupports" => Ok(__FieldTag::__grounding_supports),
"grounding_supports" => Ok(__FieldTag::__grounding_supports),
"references" => Ok(__FieldTag::__references),
"relatedQuestions" => Ok(__FieldTag::__related_questions),
"related_questions" => Ok(__FieldTag::__related_questions),
"steps" => Ok(__FieldTag::__steps),
"queryUnderstandingInfo" => Ok(__FieldTag::__query_understanding_info),
"query_understanding_info" => {
Ok(__FieldTag::__query_understanding_info)
}
"answerSkippedReasons" => Ok(__FieldTag::__answer_skipped_reasons),
"answer_skipped_reasons" => Ok(__FieldTag::__answer_skipped_reasons),
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"completeTime" => Ok(__FieldTag::__complete_time),
"complete_time" => Ok(__FieldTag::__complete_time),
"safetyRatings" => Ok(__FieldTag::__safety_ratings),
"safety_ratings" => Ok(__FieldTag::__safety_ratings),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Answer;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Answer")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__state => {
if !fields.insert(__FieldTag::__state) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for state",
));
}
result.state = map
.next_value::<std::option::Option<crate::model::answer::State>>()?
.unwrap_or_default();
}
__FieldTag::__answer_text => {
if !fields.insert(__FieldTag::__answer_text) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for answer_text",
));
}
result.answer_text = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__grounding_score => {
if !fields.insert(__FieldTag::__grounding_score) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for grounding_score",
));
}
struct __With(std::option::Option<f64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F64> >::deserialize(deserializer).map(__With)
}
}
result.grounding_score = map.next_value::<__With>()?.0;
}
__FieldTag::__citations => {
if !fields.insert(__FieldTag::__citations) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for citations",
));
}
result.citations =
map.next_value::<std::option::Option<
std::vec::Vec<crate::model::answer::Citation>,
>>()?
.unwrap_or_default();
}
__FieldTag::__grounding_supports => {
if !fields.insert(__FieldTag::__grounding_supports) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for grounding_supports",
));
}
result.grounding_supports = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::answer::GroundingSupport>,
>>()?
.unwrap_or_default();
}
__FieldTag::__references => {
if !fields.insert(__FieldTag::__references) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for references",
));
}
result.references =
map.next_value::<std::option::Option<
std::vec::Vec<crate::model::answer::Reference>,
>>()?
.unwrap_or_default();
}
__FieldTag::__related_questions => {
if !fields.insert(__FieldTag::__related_questions) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for related_questions",
));
}
result.related_questions = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__steps => {
if !fields.insert(__FieldTag::__steps) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for steps",
));
}
result.steps = map.next_value::<std::option::Option<std::vec::Vec<crate::model::answer::Step>>>()?.unwrap_or_default();
}
__FieldTag::__query_understanding_info => {
if !fields.insert(__FieldTag::__query_understanding_info) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for query_understanding_info",
));
}
result.query_understanding_info =
map.next_value::<std::option::Option<
crate::model::answer::QueryUnderstandingInfo,
>>()?;
}
__FieldTag::__answer_skipped_reasons => {
if !fields.insert(__FieldTag::__answer_skipped_reasons) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for answer_skipped_reasons",
));
}
result.answer_skipped_reasons = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::answer::AnswerSkippedReason>,
>>()?
.unwrap_or_default();
}
__FieldTag::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__complete_time => {
if !fields.insert(__FieldTag::__complete_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for complete_time",
));
}
result.complete_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__safety_ratings => {
if !fields.insert(__FieldTag::__safety_ratings) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for safety_ratings",
));
}
result.safety_ratings = map.next_value::<std::option::Option<std::vec::Vec<crate::model::SafetyRating>>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::answer::Citation {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__start_index,
__end_index,
__sources,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Citation")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"startIndex" => Ok(__FieldTag::__start_index),
"start_index" => Ok(__FieldTag::__start_index),
"endIndex" => Ok(__FieldTag::__end_index),
"end_index" => Ok(__FieldTag::__end_index),
"sources" => Ok(__FieldTag::__sources),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::answer::Citation;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Citation")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__start_index => {
if !fields.insert(__FieldTag::__start_index) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for start_index",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.start_index = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__end_index => {
if !fields.insert(__FieldTag::__end_index) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for end_index",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.end_index = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__sources => {
if !fields.insert(__FieldTag::__sources) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for sources",
));
}
result.sources = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::answer::CitationSource>,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::answer::CitationSource {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__reference_id,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for CitationSource")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"referenceId" => Ok(__FieldTag::__reference_id),
"reference_id" => Ok(__FieldTag::__reference_id),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::answer::CitationSource;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CitationSource")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__reference_id => {
if !fields.insert(__FieldTag::__reference_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for reference_id",
));
}
result.reference_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::answer::GroundingSupport {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__start_index,
__end_index,
__grounding_score,
__grounding_check_required,
__sources,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for GroundingSupport")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"startIndex" => Ok(__FieldTag::__start_index),
"start_index" => Ok(__FieldTag::__start_index),
"endIndex" => Ok(__FieldTag::__end_index),
"end_index" => Ok(__FieldTag::__end_index),
"groundingScore" => Ok(__FieldTag::__grounding_score),
"grounding_score" => Ok(__FieldTag::__grounding_score),
"groundingCheckRequired" => Ok(__FieldTag::__grounding_check_required),
"grounding_check_required" => {
Ok(__FieldTag::__grounding_check_required)
}
"sources" => Ok(__FieldTag::__sources),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::answer::GroundingSupport;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GroundingSupport")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__start_index => {
if !fields.insert(__FieldTag::__start_index) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for start_index",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.start_index = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__end_index => {
if !fields.insert(__FieldTag::__end_index) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for end_index",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.end_index = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__grounding_score => {
if !fields.insert(__FieldTag::__grounding_score) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for grounding_score",
));
}
struct __With(std::option::Option<f64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F64> >::deserialize(deserializer).map(__With)
}
}
result.grounding_score = map.next_value::<__With>()?.0;
}
__FieldTag::__grounding_check_required => {
if !fields.insert(__FieldTag::__grounding_check_required) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for grounding_check_required",
));
}
result.grounding_check_required =
map.next_value::<std::option::Option<bool>>()?;
}
__FieldTag::__sources => {
if !fields.insert(__FieldTag::__sources) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for sources",
));
}
result.sources = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::answer::CitationSource>,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::answer::Reference {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__unstructured_document_info,
__chunk_info,
__structured_document_info,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Reference")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"unstructuredDocumentInfo" => {
Ok(__FieldTag::__unstructured_document_info)
}
"unstructured_document_info" => {
Ok(__FieldTag::__unstructured_document_info)
}
"chunkInfo" => Ok(__FieldTag::__chunk_info),
"chunk_info" => Ok(__FieldTag::__chunk_info),
"structuredDocumentInfo" => Ok(__FieldTag::__structured_document_info),
"structured_document_info" => {
Ok(__FieldTag::__structured_document_info)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::answer::Reference;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Reference")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__unstructured_document_info => {
if !fields.insert(__FieldTag::__unstructured_document_info) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for unstructured_document_info",
));
}
if result.content.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `content`, a oneof with full ID .google.cloud.discoveryengine.v1.Answer.Reference.unstructured_document_info, latest field was unstructuredDocumentInfo",
));
}
result.content = std::option::Option::Some(
crate::model::answer::reference::Content::UnstructuredDocumentInfo(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::answer::reference::UnstructuredDocumentInfo>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__chunk_info => {
if !fields.insert(__FieldTag::__chunk_info) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for chunk_info",
));
}
if result.content.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `content`, a oneof with full ID .google.cloud.discoveryengine.v1.Answer.Reference.chunk_info, latest field was chunkInfo",
));
}
result.content = std::option::Option::Some(
crate::model::answer::reference::Content::ChunkInfo(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::answer::reference::ChunkInfo>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__structured_document_info => {
if !fields.insert(__FieldTag::__structured_document_info) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for structured_document_info",
));
}
if result.content.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `content`, a oneof with full ID .google.cloud.discoveryengine.v1.Answer.Reference.structured_document_info, latest field was structuredDocumentInfo",
));
}
result.content = std::option::Option::Some(
crate::model::answer::reference::Content::StructuredDocumentInfo(
map.next_value::<std::option::Option<
std::boxed::Box<
crate::model::answer::reference::StructuredDocumentInfo,
>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::answer::reference::UnstructuredDocumentInfo {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__document,
__uri,
__title,
__chunk_contents,
__struct_data,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for UnstructuredDocumentInfo")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"document" => Ok(__FieldTag::__document),
"uri" => Ok(__FieldTag::__uri),
"title" => Ok(__FieldTag::__title),
"chunkContents" => Ok(__FieldTag::__chunk_contents),
"chunk_contents" => Ok(__FieldTag::__chunk_contents),
"structData" => Ok(__FieldTag::__struct_data),
"struct_data" => Ok(__FieldTag::__struct_data),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::answer::reference::UnstructuredDocumentInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct UnstructuredDocumentInfo")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__document => {
if !fields.insert(__FieldTag::__document) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for document",
));
}
result.document = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__uri => {
if !fields.insert(__FieldTag::__uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for uri",
));
}
result.uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__title => {
if !fields.insert(__FieldTag::__title) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for title",
));
}
result.title = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__chunk_contents => {
if !fields.insert(__FieldTag::__chunk_contents) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for chunk_contents",
));
}
result.chunk_contents = map.next_value::<std::option::Option<std::vec::Vec<crate::model::answer::reference::unstructured_document_info::ChunkContent>>>()?.unwrap_or_default();
}
__FieldTag::__struct_data => {
if !fields.insert(__FieldTag::__struct_data) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for struct_data",
));
}
result.struct_data =
map.next_value::<std::option::Option<wkt::Struct>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::answer::reference::unstructured_document_info::ChunkContent
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__content,
__page_identifier,
__relevance_score,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ChunkContent")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"content" => Ok(__FieldTag::__content),
"pageIdentifier" => Ok(__FieldTag::__page_identifier),
"page_identifier" => Ok(__FieldTag::__page_identifier),
"relevanceScore" => Ok(__FieldTag::__relevance_score),
"relevance_score" => Ok(__FieldTag::__relevance_score),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::answer::reference::unstructured_document_info::ChunkContent;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ChunkContent")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__content => {
if !fields.insert(__FieldTag::__content) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for content",
));
}
result.content = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__page_identifier => {
if !fields.insert(__FieldTag::__page_identifier) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_identifier",
));
}
result.page_identifier = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__relevance_score => {
if !fields.insert(__FieldTag::__relevance_score) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for relevance_score",
));
}
struct __With(std::option::Option<f32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F32> >::deserialize(deserializer).map(__With)
}
}
result.relevance_score = map.next_value::<__With>()?.0;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::answer::reference::ChunkInfo {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__chunk,
__content,
__relevance_score,
__document_metadata,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ChunkInfo")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"chunk" => Ok(__FieldTag::__chunk),
"content" => Ok(__FieldTag::__content),
"relevanceScore" => Ok(__FieldTag::__relevance_score),
"relevance_score" => Ok(__FieldTag::__relevance_score),
"documentMetadata" => Ok(__FieldTag::__document_metadata),
"document_metadata" => Ok(__FieldTag::__document_metadata),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::answer::reference::ChunkInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ChunkInfo")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__chunk => {
if !fields.insert(__FieldTag::__chunk) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for chunk",
));
}
result.chunk = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__content => {
if !fields.insert(__FieldTag::__content) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for content",
));
}
result.content = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__relevance_score => {
if !fields.insert(__FieldTag::__relevance_score) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for relevance_score",
));
}
struct __With(std::option::Option<f32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F32> >::deserialize(deserializer).map(__With)
}
}
result.relevance_score = map.next_value::<__With>()?.0;
}
__FieldTag::__document_metadata => {
if !fields.insert(__FieldTag::__document_metadata) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for document_metadata",
));
}
result.document_metadata = map.next_value::<std::option::Option<
crate::model::answer::reference::chunk_info::DocumentMetadata,
>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::answer::reference::chunk_info::DocumentMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__document,
__uri,
__title,
__page_identifier,
__struct_data,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DocumentMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"document" => Ok(__FieldTag::__document),
"uri" => Ok(__FieldTag::__uri),
"title" => Ok(__FieldTag::__title),
"pageIdentifier" => Ok(__FieldTag::__page_identifier),
"page_identifier" => Ok(__FieldTag::__page_identifier),
"structData" => Ok(__FieldTag::__struct_data),
"struct_data" => Ok(__FieldTag::__struct_data),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::answer::reference::chunk_info::DocumentMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DocumentMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__document => {
if !fields.insert(__FieldTag::__document) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for document",
));
}
result.document = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__uri => {
if !fields.insert(__FieldTag::__uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for uri",
));
}
result.uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__title => {
if !fields.insert(__FieldTag::__title) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for title",
));
}
result.title = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__page_identifier => {
if !fields.insert(__FieldTag::__page_identifier) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_identifier",
));
}
result.page_identifier = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__struct_data => {
if !fields.insert(__FieldTag::__struct_data) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for struct_data",
));
}
result.struct_data =
map.next_value::<std::option::Option<wkt::Struct>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::answer::reference::StructuredDocumentInfo {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__document,
__struct_data,
__title,
__uri,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for StructuredDocumentInfo")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"document" => Ok(__FieldTag::__document),
"structData" => Ok(__FieldTag::__struct_data),
"struct_data" => Ok(__FieldTag::__struct_data),
"title" => Ok(__FieldTag::__title),
"uri" => Ok(__FieldTag::__uri),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::answer::reference::StructuredDocumentInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct StructuredDocumentInfo")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__document => {
if !fields.insert(__FieldTag::__document) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for document",
));
}
result.document = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__struct_data => {
if !fields.insert(__FieldTag::__struct_data) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for struct_data",
));
}
result.struct_data =
map.next_value::<std::option::Option<wkt::Struct>>()?;
}
__FieldTag::__title => {
if !fields.insert(__FieldTag::__title) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for title",
));
}
result.title = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__uri => {
if !fields.insert(__FieldTag::__uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for uri",
));
}
result.uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::answer::Step {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__state,
__description,
__thought,
__actions,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Step")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"state" => Ok(__FieldTag::__state),
"description" => Ok(__FieldTag::__description),
"thought" => Ok(__FieldTag::__thought),
"actions" => Ok(__FieldTag::__actions),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::answer::Step;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Step")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__state => {
if !fields.insert(__FieldTag::__state) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for state",
));
}
result.state = map.next_value::<std::option::Option<crate::model::answer::step::State>>()?.unwrap_or_default();
}
__FieldTag::__description => {
if !fields.insert(__FieldTag::__description) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for description",
));
}
result.description = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__thought => {
if !fields.insert(__FieldTag::__thought) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for thought",
));
}
result.thought = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__actions => {
if !fields.insert(__FieldTag::__actions) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for actions",
));
}
result.actions = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::answer::step::Action>,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::answer::step::Action {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__search_action,
__observation,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Action")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"searchAction" => Ok(__FieldTag::__search_action),
"search_action" => Ok(__FieldTag::__search_action),
"observation" => Ok(__FieldTag::__observation),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::answer::step::Action;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Action")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__search_action => {
if !fields.insert(__FieldTag::__search_action) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for search_action",
));
}
if result.action.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `action`, a oneof with full ID .google.cloud.discoveryengine.v1.Answer.Step.Action.search_action, latest field was searchAction",
));
}
result.action = std::option::Option::Some(
crate::model::answer::step::action::Action::SearchAction(
map.next_value::<std::option::Option<
std::boxed::Box<
crate::model::answer::step::action::SearchAction,
>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__observation => {
if !fields.insert(__FieldTag::__observation) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for observation",
));
}
result.observation = map.next_value::<std::option::Option<
crate::model::answer::step::action::Observation,
>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::answer::step::action::SearchAction {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__query,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SearchAction")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"query" => Ok(__FieldTag::__query),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::answer::step::action::SearchAction;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SearchAction")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__query => {
if !fields.insert(__FieldTag::__query) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for query",
));
}
result.query = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::answer::step::action::Observation {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__search_results,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Observation")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"searchResults" => Ok(__FieldTag::__search_results),
"search_results" => Ok(__FieldTag::__search_results),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::answer::step::action::Observation;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Observation")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__search_results => {
if !fields.insert(__FieldTag::__search_results) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for search_results",
));
}
result.search_results = map.next_value::<std::option::Option<std::vec::Vec<crate::model::answer::step::action::observation::SearchResult>>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::answer::step::action::observation::SearchResult {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__document,
__uri,
__title,
__snippet_info,
__chunk_info,
__struct_data,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SearchResult")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"document" => Ok(__FieldTag::__document),
"uri" => Ok(__FieldTag::__uri),
"title" => Ok(__FieldTag::__title),
"snippetInfo" => Ok(__FieldTag::__snippet_info),
"snippet_info" => Ok(__FieldTag::__snippet_info),
"chunkInfo" => Ok(__FieldTag::__chunk_info),
"chunk_info" => Ok(__FieldTag::__chunk_info),
"structData" => Ok(__FieldTag::__struct_data),
"struct_data" => Ok(__FieldTag::__struct_data),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::answer::step::action::observation::SearchResult;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SearchResult")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__document => {
if !fields.insert(__FieldTag::__document) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for document",
));
}
result.document = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__uri => {
if !fields.insert(__FieldTag::__uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for uri",
));
}
result.uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__title => {
if !fields.insert(__FieldTag::__title) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for title",
));
}
result.title = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__snippet_info => {
if !fields.insert(__FieldTag::__snippet_info) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for snippet_info",
));
}
result.snippet_info = map.next_value::<std::option::Option<std::vec::Vec<crate::model::answer::step::action::observation::search_result::SnippetInfo>>>()?.unwrap_or_default();
}
__FieldTag::__chunk_info => {
if !fields.insert(__FieldTag::__chunk_info) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for chunk_info",
));
}
result.chunk_info = map.next_value::<std::option::Option<std::vec::Vec<crate::model::answer::step::action::observation::search_result::ChunkInfo>>>()?.unwrap_or_default();
}
__FieldTag::__struct_data => {
if !fields.insert(__FieldTag::__struct_data) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for struct_data",
));
}
result.struct_data =
map.next_value::<std::option::Option<wkt::Struct>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::answer::step::action::observation::search_result::SnippetInfo
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__snippet,
__snippet_status,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SnippetInfo")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"snippet" => Ok(__FieldTag::__snippet),
"snippetStatus" => Ok(__FieldTag::__snippet_status),
"snippet_status" => Ok(__FieldTag::__snippet_status),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::answer::step::action::observation::search_result::SnippetInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SnippetInfo")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__snippet => {
if !fields.insert(__FieldTag::__snippet) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for snippet",
));
}
result.snippet = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__snippet_status => {
if !fields.insert(__FieldTag::__snippet_status) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for snippet_status",
));
}
result.snippet_status = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::answer::step::action::observation::search_result::ChunkInfo
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__chunk,
__content,
__relevance_score,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ChunkInfo")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"chunk" => Ok(__FieldTag::__chunk),
"content" => Ok(__FieldTag::__content),
"relevanceScore" => Ok(__FieldTag::__relevance_score),
"relevance_score" => Ok(__FieldTag::__relevance_score),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::answer::step::action::observation::search_result::ChunkInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ChunkInfo")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__chunk => {
if !fields.insert(__FieldTag::__chunk) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for chunk",
));
}
result.chunk = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__content => {
if !fields.insert(__FieldTag::__content) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for content",
));
}
result.content = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__relevance_score => {
if !fields.insert(__FieldTag::__relevance_score) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for relevance_score",
));
}
struct __With(std::option::Option<f32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F32> >::deserialize(deserializer).map(__With)
}
}
result.relevance_score = map.next_value::<__With>()?.0;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::answer::QueryUnderstandingInfo {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__query_classification_info,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for QueryUnderstandingInfo")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"queryClassificationInfo" => {
Ok(__FieldTag::__query_classification_info)
}
"query_classification_info" => {
Ok(__FieldTag::__query_classification_info)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::answer::QueryUnderstandingInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct QueryUnderstandingInfo")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__query_classification_info => {
if !fields.insert(__FieldTag::__query_classification_info) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for query_classification_info",
));
}
result.query_classification_info = map.next_value::<std::option::Option<std::vec::Vec<crate::model::answer::query_understanding_info::QueryClassificationInfo>>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::answer::query_understanding_info::QueryClassificationInfo
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__type,
__positive,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for QueryClassificationInfo")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"type" => Ok(__FieldTag::__type),
"positive" => Ok(__FieldTag::__positive),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::answer::query_understanding_info::QueryClassificationInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct QueryClassificationInfo")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__type => {
if !fields.insert(__FieldTag::__type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for type",
));
}
result.r#type = map.next_value::<std::option::Option<crate::model::answer::query_understanding_info::query_classification_info::Type>>()?.unwrap_or_default();
}
__FieldTag::__positive => {
if !fields.insert(__FieldTag::__positive) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for positive",
));
}
result.positive = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "assistant-service",
feature = "conversational-search-service",
feature = "session-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::AssistAnswer {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
__state,
__replies,
__assist_skipped_reasons,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for AssistAnswer")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
"state" => Ok(__FieldTag::__state),
"replies" => Ok(__FieldTag::__replies),
"assistSkippedReasons" => Ok(__FieldTag::__assist_skipped_reasons),
"assist_skipped_reasons" => Ok(__FieldTag::__assist_skipped_reasons),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::AssistAnswer;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct AssistAnswer")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__state => {
if !fields.insert(__FieldTag::__state) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for state",
));
}
result.state = map.next_value::<std::option::Option<crate::model::assist_answer::State>>()?.unwrap_or_default();
}
__FieldTag::__replies => {
if !fields.insert(__FieldTag::__replies) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for replies",
));
}
result.replies = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::assist_answer::Reply>,
>>()?
.unwrap_or_default();
}
__FieldTag::__assist_skipped_reasons => {
if !fields.insert(__FieldTag::__assist_skipped_reasons) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for assist_skipped_reasons",
));
}
result.assist_skipped_reasons = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::assist_answer::AssistSkippedReason>,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "assistant-service",
feature = "conversational-search-service",
feature = "session-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::assist_answer::Reply {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__grounded_content,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Reply")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"groundedContent" => Ok(__FieldTag::__grounded_content),
"grounded_content" => Ok(__FieldTag::__grounded_content),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::assist_answer::Reply;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Reply")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__grounded_content => {
if !fields.insert(__FieldTag::__grounded_content) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for grounded_content",
));
}
if result.reply.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `reply`, a oneof with full ID .google.cloud.discoveryengine.v1.AssistAnswer.Reply.grounded_content, latest field was groundedContent",
));
}
result.reply = std::option::Option::Some(
crate::model::assist_answer::reply::Reply::GroundedContent(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::AssistantGroundedContent>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "assistant-service",
feature = "conversational-search-service",
feature = "session-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::AssistantContent {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__text,
__inline_data,
__file,
__executable_code,
__code_execution_result,
__role,
__thought,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for AssistantContent")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"text" => Ok(__FieldTag::__text),
"inlineData" => Ok(__FieldTag::__inline_data),
"inline_data" => Ok(__FieldTag::__inline_data),
"file" => Ok(__FieldTag::__file),
"executableCode" => Ok(__FieldTag::__executable_code),
"executable_code" => Ok(__FieldTag::__executable_code),
"codeExecutionResult" => Ok(__FieldTag::__code_execution_result),
"code_execution_result" => Ok(__FieldTag::__code_execution_result),
"role" => Ok(__FieldTag::__role),
"thought" => Ok(__FieldTag::__thought),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::AssistantContent;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct AssistantContent")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__text => {
if !fields.insert(__FieldTag::__text) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for text",
));
}
if result.data.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `data`, a oneof with full ID .google.cloud.discoveryengine.v1.AssistantContent.text, latest field was text",
));
}
result.data = std::option::Option::Some(
crate::model::assistant_content::Data::Text(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__inline_data => {
if !fields.insert(__FieldTag::__inline_data) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for inline_data",
));
}
if result.data.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `data`, a oneof with full ID .google.cloud.discoveryengine.v1.AssistantContent.inline_data, latest field was inlineData",
));
}
result.data = std::option::Option::Some(
crate::model::assistant_content::Data::InlineData(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::assistant_content::Blob>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__file => {
if !fields.insert(__FieldTag::__file) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for file",
));
}
if result.data.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `data`, a oneof with full ID .google.cloud.discoveryengine.v1.AssistantContent.file, latest field was file",
));
}
result.data = std::option::Option::Some(
crate::model::assistant_content::Data::File(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::assistant_content::File>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__executable_code => {
if !fields.insert(__FieldTag::__executable_code) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for executable_code",
));
}
if result.data.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `data`, a oneof with full ID .google.cloud.discoveryengine.v1.AssistantContent.executable_code, latest field was executableCode",
));
}
result.data = std::option::Option::Some(
crate::model::assistant_content::Data::ExecutableCode(
map.next_value::<std::option::Option<
std::boxed::Box<
crate::model::assistant_content::ExecutableCode,
>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__code_execution_result => {
if !fields.insert(__FieldTag::__code_execution_result) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for code_execution_result",
));
}
if result.data.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `data`, a oneof with full ID .google.cloud.discoveryengine.v1.AssistantContent.code_execution_result, latest field was codeExecutionResult",
));
}
result.data = std::option::Option::Some(
crate::model::assistant_content::Data::CodeExecutionResult(
map.next_value::<std::option::Option<
std::boxed::Box<
crate::model::assistant_content::CodeExecutionResult,
>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__role => {
if !fields.insert(__FieldTag::__role) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for role",
));
}
result.role = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__thought => {
if !fields.insert(__FieldTag::__thought) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for thought",
));
}
result.thought = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "assistant-service",
feature = "conversational-search-service",
feature = "session-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::assistant_content::Blob {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__mime_type,
__data,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Blob")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"mimeType" => Ok(__FieldTag::__mime_type),
"mime_type" => Ok(__FieldTag::__mime_type),
"data" => Ok(__FieldTag::__data),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::assistant_content::Blob;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Blob")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__mime_type => {
if !fields.insert(__FieldTag::__mime_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for mime_type",
));
}
result.mime_type = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__data => {
if !fields.insert(__FieldTag::__data) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for data",
));
}
struct __With(std::option::Option<::bytes::Bytes>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<serde_with::base64::Base64> >::deserialize(deserializer).map(__With)
}
}
result.data = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "assistant-service",
feature = "conversational-search-service",
feature = "session-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::assistant_content::File {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__mime_type,
__file_id,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for File")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"mimeType" => Ok(__FieldTag::__mime_type),
"mime_type" => Ok(__FieldTag::__mime_type),
"fileId" => Ok(__FieldTag::__file_id),
"file_id" => Ok(__FieldTag::__file_id),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::assistant_content::File;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct File")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__mime_type => {
if !fields.insert(__FieldTag::__mime_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for mime_type",
));
}
result.mime_type = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__file_id => {
if !fields.insert(__FieldTag::__file_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for file_id",
));
}
result.file_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "assistant-service",
feature = "conversational-search-service",
feature = "session-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::assistant_content::ExecutableCode {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__code,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ExecutableCode")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"code" => Ok(__FieldTag::__code),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::assistant_content::ExecutableCode;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ExecutableCode")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__code => {
if !fields.insert(__FieldTag::__code) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for code",
));
}
result.code = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "assistant-service",
feature = "conversational-search-service",
feature = "session-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::assistant_content::CodeExecutionResult {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__outcome,
__output,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for CodeExecutionResult")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"outcome" => Ok(__FieldTag::__outcome),
"output" => Ok(__FieldTag::__output),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::assistant_content::CodeExecutionResult;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CodeExecutionResult")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__outcome => {
if !fields.insert(__FieldTag::__outcome) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for outcome",
));
}
result.outcome = map
.next_value::<std::option::Option<
crate::model::assistant_content::code_execution_result::Outcome,
>>()?
.unwrap_or_default();
}
__FieldTag::__output => {
if !fields.insert(__FieldTag::__output) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for output",
));
}
result.output = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "assistant-service",
feature = "conversational-search-service",
feature = "session-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::AssistantGroundedContent {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__text_grounding_metadata,
__content,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for AssistantGroundedContent")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"textGroundingMetadata" => Ok(__FieldTag::__text_grounding_metadata),
"text_grounding_metadata" => Ok(__FieldTag::__text_grounding_metadata),
"content" => Ok(__FieldTag::__content),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::AssistantGroundedContent;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct AssistantGroundedContent")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__text_grounding_metadata => {
if !fields.insert(__FieldTag::__text_grounding_metadata) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for text_grounding_metadata",
));
}
if result.metadata.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `metadata`, a oneof with full ID .google.cloud.discoveryengine.v1.AssistantGroundedContent.text_grounding_metadata, latest field was textGroundingMetadata",
));
}
result.metadata = std::option::Option::Some(
crate::model::assistant_grounded_content::Metadata::TextGroundingMetadata(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::assistant_grounded_content::TextGroundingMetadata>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__content => {
if !fields.insert(__FieldTag::__content) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for content",
));
}
result.content = map
.next_value::<std::option::Option<crate::model::AssistantContent>>(
)?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "assistant-service",
feature = "conversational-search-service",
feature = "session-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::assistant_grounded_content::TextGroundingMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__segments,
__references,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for TextGroundingMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"segments" => Ok(__FieldTag::__segments),
"references" => Ok(__FieldTag::__references),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::assistant_grounded_content::TextGroundingMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct TextGroundingMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__segments => {
if !fields.insert(__FieldTag::__segments) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for segments",
));
}
result.segments = map.next_value::<std::option::Option<std::vec::Vec<crate::model::assistant_grounded_content::text_grounding_metadata::Segment>>>()?.unwrap_or_default();
}
__FieldTag::__references => {
if !fields.insert(__FieldTag::__references) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for references",
));
}
result.references = map.next_value::<std::option::Option<std::vec::Vec<crate::model::assistant_grounded_content::text_grounding_metadata::Reference>>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "assistant-service",
feature = "conversational-search-service",
feature = "session-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::assistant_grounded_content::text_grounding_metadata::Segment
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__start_index,
__end_index,
__reference_indices,
__grounding_score,
__text,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Segment")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"startIndex" => Ok(__FieldTag::__start_index),
"start_index" => Ok(__FieldTag::__start_index),
"endIndex" => Ok(__FieldTag::__end_index),
"end_index" => Ok(__FieldTag::__end_index),
"referenceIndices" => Ok(__FieldTag::__reference_indices),
"reference_indices" => Ok(__FieldTag::__reference_indices),
"groundingScore" => Ok(__FieldTag::__grounding_score),
"grounding_score" => Ok(__FieldTag::__grounding_score),
"text" => Ok(__FieldTag::__text),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::assistant_grounded_content::text_grounding_metadata::Segment;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Segment")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__start_index => {
if !fields.insert(__FieldTag::__start_index) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for start_index",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.start_index = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__end_index => {
if !fields.insert(__FieldTag::__end_index) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for end_index",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.end_index = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__reference_indices => {
if !fields.insert(__FieldTag::__reference_indices) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for reference_indices",
));
}
struct __With(std::option::Option<std::vec::Vec<i32>>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::<
std::option::Option<std::vec::Vec<wkt::internal::I32>>,
>::deserialize(deserializer)
.map(__With)
}
}
result.reference_indices =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__grounding_score => {
if !fields.insert(__FieldTag::__grounding_score) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for grounding_score",
));
}
struct __With(std::option::Option<f32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F32> >::deserialize(deserializer).map(__With)
}
}
result.grounding_score =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__text => {
if !fields.insert(__FieldTag::__text) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for text",
));
}
result.text = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "assistant-service",
feature = "conversational-search-service",
feature = "session-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::assistant_grounded_content::text_grounding_metadata::Reference
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__content,
__document_metadata,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Reference")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"content" => Ok(__FieldTag::__content),
"documentMetadata" => Ok(__FieldTag::__document_metadata),
"document_metadata" => Ok(__FieldTag::__document_metadata),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::assistant_grounded_content::text_grounding_metadata::Reference;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Reference")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__content => {
if !fields.insert(__FieldTag::__content) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for content",
));
}
result.content = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__document_metadata => {
if !fields.insert(__FieldTag::__document_metadata) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for document_metadata",
));
}
result.document_metadata = map.next_value::<std::option::Option<crate::model::assistant_grounded_content::text_grounding_metadata::reference::DocumentMetadata>>()?
;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "assistant-service",
feature = "conversational-search-service",
feature = "session-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::assistant_grounded_content::text_grounding_metadata::reference::DocumentMetadata
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__document,
__uri,
__title,
__page_identifier,
__domain,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DocumentMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"document" => Ok(__FieldTag::__document),
"uri" => Ok(__FieldTag::__uri),
"title" => Ok(__FieldTag::__title),
"pageIdentifier" => Ok(__FieldTag::__page_identifier),
"page_identifier" => Ok(__FieldTag::__page_identifier),
"domain" => Ok(__FieldTag::__domain),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::assistant_grounded_content::text_grounding_metadata::reference::DocumentMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DocumentMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__document => {
if !fields.insert(__FieldTag::__document) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for document",
));
}
result.document =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__FieldTag::__uri => {
if !fields.insert(__FieldTag::__uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for uri",
));
}
result.uri =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__FieldTag::__title => {
if !fields.insert(__FieldTag::__title) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for title",
));
}
result.title =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__FieldTag::__page_identifier => {
if !fields.insert(__FieldTag::__page_identifier) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_identifier",
));
}
result.page_identifier =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__FieldTag::__domain => {
if !fields.insert(__FieldTag::__domain) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for domain",
));
}
result.domain =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[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",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::Assistant {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Assistant")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Assistant;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Assistant")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "assistant-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::AssistUserMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__time_zone,
__preferred_language_code,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for AssistUserMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"timeZone" => Ok(__FieldTag::__time_zone),
"time_zone" => Ok(__FieldTag::__time_zone),
"preferredLanguageCode" => Ok(__FieldTag::__preferred_language_code),
"preferred_language_code" => Ok(__FieldTag::__preferred_language_code),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::AssistUserMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct AssistUserMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__time_zone => {
if !fields.insert(__FieldTag::__time_zone) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for time_zone",
));
}
result.time_zone = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__preferred_language_code => {
if !fields.insert(__FieldTag::__preferred_language_code) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for preferred_language_code",
));
}
result.preferred_language_code = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "assistant-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::StreamAssistRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
__query,
__session,
__user_metadata,
__tools_spec,
__generation_spec,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for StreamAssistRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
"query" => Ok(__FieldTag::__query),
"session" => Ok(__FieldTag::__session),
"userMetadata" => Ok(__FieldTag::__user_metadata),
"user_metadata" => Ok(__FieldTag::__user_metadata),
"toolsSpec" => Ok(__FieldTag::__tools_spec),
"tools_spec" => Ok(__FieldTag::__tools_spec),
"generationSpec" => Ok(__FieldTag::__generation_spec),
"generation_spec" => Ok(__FieldTag::__generation_spec),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::StreamAssistRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct StreamAssistRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__query => {
if !fields.insert(__FieldTag::__query) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for query",
));
}
result.query =
map.next_value::<std::option::Option<crate::model::Query>>()?;
}
__FieldTag::__session => {
if !fields.insert(__FieldTag::__session) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for session",
));
}
result.session = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__user_metadata => {
if !fields.insert(__FieldTag::__user_metadata) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for user_metadata",
));
}
result.user_metadata = map.next_value::<std::option::Option<crate::model::AssistUserMetadata>>()?
;
}
__FieldTag::__tools_spec => {
if !fields.insert(__FieldTag::__tools_spec) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for tools_spec",
));
}
result.tools_spec = map.next_value::<std::option::Option<
crate::model::stream_assist_request::ToolsSpec,
>>()?;
}
__FieldTag::__generation_spec => {
if !fields.insert(__FieldTag::__generation_spec) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for generation_spec",
));
}
result.generation_spec = map.next_value::<std::option::Option<
crate::model::stream_assist_request::GenerationSpec,
>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "assistant-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::stream_assist_request::ToolsSpec {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__vertex_ai_search_spec,
__web_grounding_spec,
__image_generation_spec,
__video_generation_spec,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ToolsSpec")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"vertexAiSearchSpec" => Ok(__FieldTag::__vertex_ai_search_spec),
"vertex_ai_search_spec" => Ok(__FieldTag::__vertex_ai_search_spec),
"webGroundingSpec" => Ok(__FieldTag::__web_grounding_spec),
"web_grounding_spec" => Ok(__FieldTag::__web_grounding_spec),
"imageGenerationSpec" => Ok(__FieldTag::__image_generation_spec),
"image_generation_spec" => Ok(__FieldTag::__image_generation_spec),
"videoGenerationSpec" => Ok(__FieldTag::__video_generation_spec),
"video_generation_spec" => Ok(__FieldTag::__video_generation_spec),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::stream_assist_request::ToolsSpec;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ToolsSpec")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__vertex_ai_search_spec => {
if !fields.insert(__FieldTag::__vertex_ai_search_spec) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for vertex_ai_search_spec",
));
}
result.vertex_ai_search_spec = map.next_value::<std::option::Option<
crate::model::stream_assist_request::tools_spec::VertexAiSearchSpec,
>>()?;
}
__FieldTag::__web_grounding_spec => {
if !fields.insert(__FieldTag::__web_grounding_spec) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for web_grounding_spec",
));
}
result.web_grounding_spec = map.next_value::<std::option::Option<
crate::model::stream_assist_request::tools_spec::WebGroundingSpec,
>>()?;
}
__FieldTag::__image_generation_spec => {
if !fields.insert(__FieldTag::__image_generation_spec) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for image_generation_spec",
));
}
result.image_generation_spec = map.next_value::<std::option::Option<crate::model::stream_assist_request::tools_spec::ImageGenerationSpec>>()?
;
}
__FieldTag::__video_generation_spec => {
if !fields.insert(__FieldTag::__video_generation_spec) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for video_generation_spec",
));
}
result.video_generation_spec = map.next_value::<std::option::Option<crate::model::stream_assist_request::tools_spec::VideoGenerationSpec>>()?
;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "assistant-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::stream_assist_request::tools_spec::VertexAiSearchSpec
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__data_store_specs,
__filter,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for VertexAiSearchSpec")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"dataStoreSpecs" => Ok(__FieldTag::__data_store_specs),
"data_store_specs" => Ok(__FieldTag::__data_store_specs),
"filter" => Ok(__FieldTag::__filter),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::stream_assist_request::tools_spec::VertexAiSearchSpec;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct VertexAiSearchSpec")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__data_store_specs => {
if !fields.insert(__FieldTag::__data_store_specs) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for data_store_specs",
));
}
result.data_store_specs = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::search_request::DataStoreSpec>,
>>()?
.unwrap_or_default();
}
__FieldTag::__filter => {
if !fields.insert(__FieldTag::__filter) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for filter",
));
}
result.filter = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "assistant-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::stream_assist_request::tools_spec::WebGroundingSpec
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for WebGroundingSpec")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
Ok(__FieldTag::Unknown(value.to_string()))
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::stream_assist_request::tools_spec::WebGroundingSpec;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct WebGroundingSpec")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "assistant-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::stream_assist_request::tools_spec::ImageGenerationSpec
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ImageGenerationSpec")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
Ok(__FieldTag::Unknown(value.to_string()))
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::stream_assist_request::tools_spec::ImageGenerationSpec;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ImageGenerationSpec")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "assistant-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::stream_assist_request::tools_spec::VideoGenerationSpec
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for VideoGenerationSpec")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
Ok(__FieldTag::Unknown(value.to_string()))
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::stream_assist_request::tools_spec::VideoGenerationSpec;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct VideoGenerationSpec")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "assistant-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::stream_assist_request::GenerationSpec {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__model_id,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for GenerationSpec")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"modelId" => Ok(__FieldTag::__model_id),
"model_id" => Ok(__FieldTag::__model_id),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::stream_assist_request::GenerationSpec;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GenerationSpec")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__model_id => {
if !fields.insert(__FieldTag::__model_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for model_id",
));
}
result.model_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "assistant-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::StreamAssistResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__answer,
__session_info,
__assist_token,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for StreamAssistResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"answer" => Ok(__FieldTag::__answer),
"sessionInfo" => Ok(__FieldTag::__session_info),
"session_info" => Ok(__FieldTag::__session_info),
"assistToken" => Ok(__FieldTag::__assist_token),
"assist_token" => Ok(__FieldTag::__assist_token),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::StreamAssistResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct StreamAssistResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__answer => {
if !fields.insert(__FieldTag::__answer) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for answer",
));
}
result.answer = map
.next_value::<std::option::Option<crate::model::AssistAnswer>>()?;
}
__FieldTag::__session_info => {
if !fields.insert(__FieldTag::__session_info) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for session_info",
));
}
result.session_info = map.next_value::<std::option::Option<
crate::model::stream_assist_response::SessionInfo,
>>()?;
}
__FieldTag::__assist_token => {
if !fields.insert(__FieldTag::__assist_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for assist_token",
));
}
result.assist_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "assistant-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::stream_assist_response::SessionInfo {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__session,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SessionInfo")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"session" => Ok(__FieldTag::__session),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::stream_assist_response::SessionInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SessionInfo")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__session => {
if !fields.insert(__FieldTag::__session) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for session",
));
}
result.session = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::Chunk {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
__id,
__content,
__relevance_score,
__document_metadata,
__derived_struct_data,
__page_span,
__chunk_metadata,
__data_urls,
__annotation_contents,
__annotation_metadata,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Chunk")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
"id" => Ok(__FieldTag::__id),
"content" => Ok(__FieldTag::__content),
"relevanceScore" => Ok(__FieldTag::__relevance_score),
"relevance_score" => Ok(__FieldTag::__relevance_score),
"documentMetadata" => Ok(__FieldTag::__document_metadata),
"document_metadata" => Ok(__FieldTag::__document_metadata),
"derivedStructData" => Ok(__FieldTag::__derived_struct_data),
"derived_struct_data" => Ok(__FieldTag::__derived_struct_data),
"pageSpan" => Ok(__FieldTag::__page_span),
"page_span" => Ok(__FieldTag::__page_span),
"chunkMetadata" => Ok(__FieldTag::__chunk_metadata),
"chunk_metadata" => Ok(__FieldTag::__chunk_metadata),
"dataUrls" => Ok(__FieldTag::__data_urls),
"data_urls" => Ok(__FieldTag::__data_urls),
"annotationContents" => Ok(__FieldTag::__annotation_contents),
"annotation_contents" => Ok(__FieldTag::__annotation_contents),
"annotationMetadata" => Ok(__FieldTag::__annotation_metadata),
"annotation_metadata" => Ok(__FieldTag::__annotation_metadata),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Chunk;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Chunk")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__id => {
if !fields.insert(__FieldTag::__id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for id",
));
}
result.id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__content => {
if !fields.insert(__FieldTag::__content) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for content",
));
}
result.content = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__relevance_score => {
if !fields.insert(__FieldTag::__relevance_score) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for relevance_score",
));
}
struct __With(std::option::Option<f64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F64> >::deserialize(deserializer).map(__With)
}
}
result.relevance_score = map.next_value::<__With>()?.0;
}
__FieldTag::__document_metadata => {
if !fields.insert(__FieldTag::__document_metadata) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for document_metadata",
));
}
result.document_metadata = map.next_value::<std::option::Option<crate::model::chunk::DocumentMetadata>>()?
;
}
__FieldTag::__derived_struct_data => {
if !fields.insert(__FieldTag::__derived_struct_data) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for derived_struct_data",
));
}
result.derived_struct_data =
map.next_value::<std::option::Option<wkt::Struct>>()?;
}
__FieldTag::__page_span => {
if !fields.insert(__FieldTag::__page_span) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_span",
));
}
result.page_span = map
.next_value::<std::option::Option<crate::model::chunk::PageSpan>>(
)?;
}
__FieldTag::__chunk_metadata => {
if !fields.insert(__FieldTag::__chunk_metadata) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for chunk_metadata",
));
}
result.chunk_metadata = map.next_value::<std::option::Option<
std::boxed::Box<crate::model::chunk::ChunkMetadata>,
>>()?;
}
__FieldTag::__data_urls => {
if !fields.insert(__FieldTag::__data_urls) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for data_urls",
));
}
result.data_urls = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__annotation_contents => {
if !fields.insert(__FieldTag::__annotation_contents) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for annotation_contents",
));
}
result.annotation_contents = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__annotation_metadata => {
if !fields.insert(__FieldTag::__annotation_metadata) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for annotation_metadata",
));
}
result.annotation_metadata = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::chunk::AnnotationMetadata>,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::chunk::DocumentMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__uri,
__title,
__struct_data,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DocumentMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"uri" => Ok(__FieldTag::__uri),
"title" => Ok(__FieldTag::__title),
"structData" => Ok(__FieldTag::__struct_data),
"struct_data" => Ok(__FieldTag::__struct_data),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::chunk::DocumentMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DocumentMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__uri => {
if !fields.insert(__FieldTag::__uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for uri",
));
}
result.uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__title => {
if !fields.insert(__FieldTag::__title) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for title",
));
}
result.title = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__struct_data => {
if !fields.insert(__FieldTag::__struct_data) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for struct_data",
));
}
result.struct_data =
map.next_value::<std::option::Option<wkt::Struct>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::chunk::PageSpan {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__page_start,
__page_end,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for PageSpan")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"pageStart" => Ok(__FieldTag::__page_start),
"page_start" => Ok(__FieldTag::__page_start),
"pageEnd" => Ok(__FieldTag::__page_end),
"page_end" => Ok(__FieldTag::__page_end),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::chunk::PageSpan;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct PageSpan")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__page_start => {
if !fields.insert(__FieldTag::__page_start) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_start",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.page_start = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__page_end => {
if !fields.insert(__FieldTag::__page_end) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_end",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.page_end = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::chunk::ChunkMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__previous_chunks,
__next_chunks,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ChunkMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"previousChunks" => Ok(__FieldTag::__previous_chunks),
"previous_chunks" => Ok(__FieldTag::__previous_chunks),
"nextChunks" => Ok(__FieldTag::__next_chunks),
"next_chunks" => Ok(__FieldTag::__next_chunks),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::chunk::ChunkMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ChunkMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__previous_chunks => {
if !fields.insert(__FieldTag::__previous_chunks) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for previous_chunks",
));
}
result.previous_chunks = map.next_value::<std::option::Option<std::vec::Vec<crate::model::Chunk>>>()?.unwrap_or_default();
}
__FieldTag::__next_chunks => {
if !fields.insert(__FieldTag::__next_chunks) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for next_chunks",
));
}
result.next_chunks = map.next_value::<std::option::Option<std::vec::Vec<crate::model::Chunk>>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::chunk::StructuredContent {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__structure_type,
__content,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for StructuredContent")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"structureType" => Ok(__FieldTag::__structure_type),
"structure_type" => Ok(__FieldTag::__structure_type),
"content" => Ok(__FieldTag::__content),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::chunk::StructuredContent;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct StructuredContent")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__structure_type => {
if !fields.insert(__FieldTag::__structure_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for structure_type",
));
}
result.structure_type = map.next_value::<std::option::Option<crate::model::chunk::StructureType>>()?.unwrap_or_default();
}
__FieldTag::__content => {
if !fields.insert(__FieldTag::__content) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for content",
));
}
result.content = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::chunk::AnnotationMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__structured_content,
__image_id,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for AnnotationMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"structuredContent" => Ok(__FieldTag::__structured_content),
"structured_content" => Ok(__FieldTag::__structured_content),
"imageId" => Ok(__FieldTag::__image_id),
"image_id" => Ok(__FieldTag::__image_id),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::chunk::AnnotationMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct AnnotationMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__structured_content => {
if !fields.insert(__FieldTag::__structured_content) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for structured_content",
));
}
result.structured_content = map.next_value::<std::option::Option<crate::model::chunk::StructuredContent>>()?
;
}
__FieldTag::__image_id => {
if !fields.insert(__FieldTag::__image_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for image_id",
));
}
result.image_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "cmek-config-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::UpdateCmekConfigRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__config,
__set_default,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for UpdateCmekConfigRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"config" => Ok(__FieldTag::__config),
"setDefault" => Ok(__FieldTag::__set_default),
"set_default" => Ok(__FieldTag::__set_default),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::UpdateCmekConfigRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct UpdateCmekConfigRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__config => {
if !fields.insert(__FieldTag::__config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for config",
));
}
result.config =
map.next_value::<std::option::Option<crate::model::CmekConfig>>()?;
}
__FieldTag::__set_default => {
if !fields.insert(__FieldTag::__set_default) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for set_default",
));
}
result.set_default = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "cmek-config-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::GetCmekConfigRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for GetCmekConfigRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::GetCmekConfigRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GetCmekConfigRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "cmek-config-service",
feature = "data-store-service",
feature = "identity-mapping-store-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::SingleRegionKey {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__kms_key,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SingleRegionKey")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"kmsKey" => Ok(__FieldTag::__kms_key),
"kms_key" => Ok(__FieldTag::__kms_key),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::SingleRegionKey;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SingleRegionKey")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__kms_key => {
if !fields.insert(__FieldTag::__kms_key) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for kms_key",
));
}
result.kms_key = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "cmek-config-service",
feature = "data-store-service",
feature = "identity-mapping-store-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::CmekConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
__kms_key,
__kms_key_version,
__state,
__is_default,
__last_rotation_timestamp_micros,
__single_region_keys,
__notebooklm_state,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for CmekConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
"kmsKey" => Ok(__FieldTag::__kms_key),
"kms_key" => Ok(__FieldTag::__kms_key),
"kmsKeyVersion" => Ok(__FieldTag::__kms_key_version),
"kms_key_version" => Ok(__FieldTag::__kms_key_version),
"state" => Ok(__FieldTag::__state),
"isDefault" => Ok(__FieldTag::__is_default),
"is_default" => Ok(__FieldTag::__is_default),
"lastRotationTimestampMicros" => {
Ok(__FieldTag::__last_rotation_timestamp_micros)
}
"last_rotation_timestamp_micros" => {
Ok(__FieldTag::__last_rotation_timestamp_micros)
}
"singleRegionKeys" => Ok(__FieldTag::__single_region_keys),
"single_region_keys" => Ok(__FieldTag::__single_region_keys),
"notebooklmState" => Ok(__FieldTag::__notebooklm_state),
"notebooklm_state" => Ok(__FieldTag::__notebooklm_state),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CmekConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CmekConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__kms_key => {
if !fields.insert(__FieldTag::__kms_key) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for kms_key",
));
}
result.kms_key = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__kms_key_version => {
if !fields.insert(__FieldTag::__kms_key_version) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for kms_key_version",
));
}
result.kms_key_version = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__state => {
if !fields.insert(__FieldTag::__state) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for state",
));
}
result.state = map.next_value::<std::option::Option<crate::model::cmek_config::State>>()?.unwrap_or_default();
}
__FieldTag::__is_default => {
if !fields.insert(__FieldTag::__is_default) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for is_default",
));
}
result.is_default = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__last_rotation_timestamp_micros => {
if !fields.insert(__FieldTag::__last_rotation_timestamp_micros) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for last_rotation_timestamp_micros",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.last_rotation_timestamp_micros =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__single_region_keys => {
if !fields.insert(__FieldTag::__single_region_keys) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for single_region_keys",
));
}
result.single_region_keys =
map.next_value::<std::option::Option<
std::vec::Vec<crate::model::SingleRegionKey>,
>>()?
.unwrap_or_default();
}
__FieldTag::__notebooklm_state => {
if !fields.insert(__FieldTag::__notebooklm_state) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for notebooklm_state",
));
}
result.notebooklm_state = map.next_value::<std::option::Option<crate::model::cmek_config::NotebookLMState>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "cmek-config-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::UpdateCmekConfigMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__create_time,
__update_time,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for UpdateCmekConfigMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"updateTime" => Ok(__FieldTag::__update_time),
"update_time" => Ok(__FieldTag::__update_time),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::UpdateCmekConfigMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct UpdateCmekConfigMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__update_time => {
if !fields.insert(__FieldTag::__update_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_time",
));
}
result.update_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "cmek-config-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ListCmekConfigsRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__parent,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ListCmekConfigsRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"parent" => Ok(__FieldTag::__parent),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListCmekConfigsRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListCmekConfigsRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "cmek-config-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ListCmekConfigsResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__cmek_configs,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ListCmekConfigsResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"cmekConfigs" => Ok(__FieldTag::__cmek_configs),
"cmek_configs" => Ok(__FieldTag::__cmek_configs),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListCmekConfigsResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListCmekConfigsResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__cmek_configs => {
if !fields.insert(__FieldTag::__cmek_configs) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cmek_configs",
));
}
result.cmek_configs = map.next_value::<std::option::Option<std::vec::Vec<crate::model::CmekConfig>>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "cmek-config-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::DeleteCmekConfigRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DeleteCmekConfigRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DeleteCmekConfigRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DeleteCmekConfigRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "cmek-config-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::DeleteCmekConfigMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__create_time,
__update_time,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DeleteCmekConfigMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"updateTime" => Ok(__FieldTag::__update_time),
"update_time" => Ok(__FieldTag::__update_time),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DeleteCmekConfigMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DeleteCmekConfigMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__update_time => {
if !fields.insert(__FieldTag::__update_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_time",
));
}
result.update_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "assistant-service",
feature = "conversational-search-service",
feature = "search-service",
feature = "serving-config-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::Interval {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__minimum,
__exclusive_minimum,
__maximum,
__exclusive_maximum,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Interval")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"minimum" => Ok(__FieldTag::__minimum),
"exclusiveMinimum" => Ok(__FieldTag::__exclusive_minimum),
"exclusive_minimum" => Ok(__FieldTag::__exclusive_minimum),
"maximum" => Ok(__FieldTag::__maximum),
"exclusiveMaximum" => Ok(__FieldTag::__exclusive_maximum),
"exclusive_maximum" => Ok(__FieldTag::__exclusive_maximum),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Interval;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Interval")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__minimum => {
if !fields.insert(__FieldTag::__minimum) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for minimum",
));
}
struct __With(std::option::Option<f64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F64> >::deserialize(deserializer).map(__With)
}
}
if result.min.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `min`, a oneof with full ID .google.cloud.discoveryengine.v1.Interval.minimum, latest field was minimum",
));
}
result.min =
std::option::Option::Some(crate::model::interval::Min::Minimum(
map.next_value::<__With>()?.0.unwrap_or_default(),
));
}
__FieldTag::__exclusive_minimum => {
if !fields.insert(__FieldTag::__exclusive_minimum) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for exclusive_minimum",
));
}
struct __With(std::option::Option<f64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F64> >::deserialize(deserializer).map(__With)
}
}
if result.min.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `min`, a oneof with full ID .google.cloud.discoveryengine.v1.Interval.exclusive_minimum, latest field was exclusiveMinimum",
));
}
result.min = std::option::Option::Some(
crate::model::interval::Min::ExclusiveMinimum(
map.next_value::<__With>()?.0.unwrap_or_default(),
),
);
}
__FieldTag::__maximum => {
if !fields.insert(__FieldTag::__maximum) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for maximum",
));
}
struct __With(std::option::Option<f64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F64> >::deserialize(deserializer).map(__With)
}
}
if result.max.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `max`, a oneof with full ID .google.cloud.discoveryengine.v1.Interval.maximum, latest field was maximum",
));
}
result.max =
std::option::Option::Some(crate::model::interval::Max::Maximum(
map.next_value::<__With>()?.0.unwrap_or_default(),
));
}
__FieldTag::__exclusive_maximum => {
if !fields.insert(__FieldTag::__exclusive_maximum) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for exclusive_maximum",
));
}
struct __With(std::option::Option<f64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F64> >::deserialize(deserializer).map(__With)
}
}
if result.max.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `max`, a oneof with full ID .google.cloud.discoveryengine.v1.Interval.exclusive_maximum, latest field was exclusiveMaximum",
));
}
result.max = std::option::Option::Some(
crate::model::interval::Max::ExclusiveMaximum(
map.next_value::<__With>()?.0.unwrap_or_default(),
),
);
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "recommendation-service", feature = "user-event-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::CustomAttribute {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__text,
__numbers,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for CustomAttribute")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"text" => Ok(__FieldTag::__text),
"numbers" => Ok(__FieldTag::__numbers),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CustomAttribute;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CustomAttribute")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__text => {
if !fields.insert(__FieldTag::__text) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for text",
));
}
result.text = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__numbers => {
if !fields.insert(__FieldTag::__numbers) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for numbers",
));
}
struct __With(std::option::Option<std::vec::Vec<f64>>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::<
std::option::Option<std::vec::Vec<wkt::internal::F64>>,
>::deserialize(deserializer)
.map(__With)
}
}
result.numbers = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "assistant-service",
feature = "conversational-search-service",
feature = "recommendation-service",
feature = "search-service",
feature = "serving-config-service",
feature = "user-event-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::UserInfo {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__user_id,
__user_agent,
__time_zone,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for UserInfo")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"userId" => Ok(__FieldTag::__user_id),
"user_id" => Ok(__FieldTag::__user_id),
"userAgent" => Ok(__FieldTag::__user_agent),
"user_agent" => Ok(__FieldTag::__user_agent),
"timeZone" => Ok(__FieldTag::__time_zone),
"time_zone" => Ok(__FieldTag::__time_zone),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::UserInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct UserInfo")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__user_id => {
if !fields.insert(__FieldTag::__user_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for user_id",
));
}
result.user_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__user_agent => {
if !fields.insert(__FieldTag::__user_agent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for user_agent",
));
}
result.user_agent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__time_zone => {
if !fields.insert(__FieldTag::__time_zone) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for time_zone",
));
}
result.time_zone = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::DoubleList {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__values,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DoubleList")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"values" => Ok(__FieldTag::__values),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DoubleList;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DoubleList")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__values => {
if !fields.insert(__FieldTag::__values) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for values",
));
}
struct __With(std::option::Option<std::vec::Vec<f64>>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::<
std::option::Option<std::vec::Vec<wkt::internal::F64>>,
>::deserialize(deserializer)
.map(__With)
}
}
result.values = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "conversational-search-service",
feature = "document-service",
feature = "recommendation-service",
feature = "search-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::Principal {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__user_id,
__group_id,
__external_entity_id,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Principal")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"userId" => Ok(__FieldTag::__user_id),
"user_id" => Ok(__FieldTag::__user_id),
"groupId" => Ok(__FieldTag::__group_id),
"group_id" => Ok(__FieldTag::__group_id),
"externalEntityId" => Ok(__FieldTag::__external_entity_id),
"external_entity_id" => Ok(__FieldTag::__external_entity_id),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Principal;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Principal")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__user_id => {
if !fields.insert(__FieldTag::__user_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for user_id",
));
}
if result.principal.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `principal`, a oneof with full ID .google.cloud.discoveryengine.v1.Principal.user_id, latest field was userId",
));
}
result.principal = std::option::Option::Some(
crate::model::principal::Principal::UserId(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__group_id => {
if !fields.insert(__FieldTag::__group_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for group_id",
));
}
if result.principal.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `principal`, a oneof with full ID .google.cloud.discoveryengine.v1.Principal.group_id, latest field was groupId",
));
}
result.principal = std::option::Option::Some(
crate::model::principal::Principal::GroupId(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__external_entity_id => {
if !fields.insert(__FieldTag::__external_entity_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for external_entity_id",
));
}
if result.principal.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `principal`, a oneof with full ID .google.cloud.discoveryengine.v1.Principal.external_entity_id, latest field was externalEntityId",
));
}
result.principal = std::option::Option::Some(
crate::model::principal::Principal::ExternalEntityId(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "data-store-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::HealthcareFhirConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__enable_configurable_schema,
__enable_static_indexing_for_batch_ingestion,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for HealthcareFhirConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"enableConfigurableSchema" => {
Ok(__FieldTag::__enable_configurable_schema)
}
"enable_configurable_schema" => {
Ok(__FieldTag::__enable_configurable_schema)
}
"enableStaticIndexingForBatchIngestion" => {
Ok(__FieldTag::__enable_static_indexing_for_batch_ingestion)
}
"enable_static_indexing_for_batch_ingestion" => {
Ok(__FieldTag::__enable_static_indexing_for_batch_ingestion)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::HealthcareFhirConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct HealthcareFhirConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__enable_configurable_schema => {
if !fields.insert(__FieldTag::__enable_configurable_schema) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for enable_configurable_schema",
));
}
result.enable_configurable_schema = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__enable_static_indexing_for_batch_ingestion => {
if !fields
.insert(__FieldTag::__enable_static_indexing_for_batch_ingestion)
{
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for enable_static_indexing_for_batch_ingestion",
));
}
result.enable_static_indexing_for_batch_ingestion = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "control-service",
feature = "conversational-search-service",
feature = "search-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::SearchLinkPromotion {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__title,
__uri,
__document,
__image_uri,
__description,
__enabled,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SearchLinkPromotion")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"title" => Ok(__FieldTag::__title),
"uri" => Ok(__FieldTag::__uri),
"document" => Ok(__FieldTag::__document),
"imageUri" => Ok(__FieldTag::__image_uri),
"image_uri" => Ok(__FieldTag::__image_uri),
"description" => Ok(__FieldTag::__description),
"enabled" => Ok(__FieldTag::__enabled),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::SearchLinkPromotion;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SearchLinkPromotion")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__title => {
if !fields.insert(__FieldTag::__title) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for title",
));
}
result.title = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__uri => {
if !fields.insert(__FieldTag::__uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for uri",
));
}
result.uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__document => {
if !fields.insert(__FieldTag::__document) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for document",
));
}
result.document = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__image_uri => {
if !fields.insert(__FieldTag::__image_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for image_uri",
));
}
result.image_uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__description => {
if !fields.insert(__FieldTag::__description) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for description",
));
}
result.description = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__enabled => {
if !fields.insert(__FieldTag::__enabled) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for enabled",
));
}
result.enabled = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "completion-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::SuggestionDenyListEntry {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__block_phrase,
__match_operator,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SuggestionDenyListEntry")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"blockPhrase" => Ok(__FieldTag::__block_phrase),
"block_phrase" => Ok(__FieldTag::__block_phrase),
"matchOperator" => Ok(__FieldTag::__match_operator),
"match_operator" => Ok(__FieldTag::__match_operator),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::SuggestionDenyListEntry;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SuggestionDenyListEntry")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__block_phrase => {
if !fields.insert(__FieldTag::__block_phrase) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for block_phrase",
));
}
result.block_phrase = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__match_operator => {
if !fields.insert(__FieldTag::__match_operator) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for match_operator",
));
}
result.match_operator = map
.next_value::<std::option::Option<
crate::model::suggestion_deny_list_entry::MatchOperator,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "completion-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::CompletionSuggestion {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__global_score,
__frequency,
__suggestion,
__language_code,
__group_id,
__group_score,
__alternative_phrases,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for CompletionSuggestion")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"globalScore" => Ok(__FieldTag::__global_score),
"global_score" => Ok(__FieldTag::__global_score),
"frequency" => Ok(__FieldTag::__frequency),
"suggestion" => Ok(__FieldTag::__suggestion),
"languageCode" => Ok(__FieldTag::__language_code),
"language_code" => Ok(__FieldTag::__language_code),
"groupId" => Ok(__FieldTag::__group_id),
"group_id" => Ok(__FieldTag::__group_id),
"groupScore" => Ok(__FieldTag::__group_score),
"group_score" => Ok(__FieldTag::__group_score),
"alternativePhrases" => Ok(__FieldTag::__alternative_phrases),
"alternative_phrases" => Ok(__FieldTag::__alternative_phrases),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CompletionSuggestion;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CompletionSuggestion")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__global_score => {
if !fields.insert(__FieldTag::__global_score) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for global_score",
));
}
struct __With(std::option::Option<f64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F64> >::deserialize(deserializer).map(__With)
}
}
if result.ranking_info.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `ranking_info`, a oneof with full ID .google.cloud.discoveryengine.v1.CompletionSuggestion.global_score, latest field was globalScore",
));
}
result.ranking_info = std::option::Option::Some(
crate::model::completion_suggestion::RankingInfo::GlobalScore(
map.next_value::<__With>()?.0.unwrap_or_default(),
),
);
}
__FieldTag::__frequency => {
if !fields.insert(__FieldTag::__frequency) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for frequency",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
if result.ranking_info.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `ranking_info`, a oneof with full ID .google.cloud.discoveryengine.v1.CompletionSuggestion.frequency, latest field was frequency",
));
}
result.ranking_info = std::option::Option::Some(
crate::model::completion_suggestion::RankingInfo::Frequency(
map.next_value::<__With>()?.0.unwrap_or_default(),
),
);
}
__FieldTag::__suggestion => {
if !fields.insert(__FieldTag::__suggestion) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for suggestion",
));
}
result.suggestion = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__language_code => {
if !fields.insert(__FieldTag::__language_code) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for language_code",
));
}
result.language_code = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__group_id => {
if !fields.insert(__FieldTag::__group_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for group_id",
));
}
result.group_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__group_score => {
if !fields.insert(__FieldTag::__group_score) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for group_score",
));
}
struct __With(std::option::Option<f64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F64> >::deserialize(deserializer).map(__With)
}
}
result.group_score = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__alternative_phrases => {
if !fields.insert(__FieldTag::__alternative_phrases) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for alternative_phrases",
));
}
result.alternative_phrases = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "completion-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::CompleteQueryRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__data_store,
__query,
__query_model,
__user_pseudo_id,
__include_tail_suggestions,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for CompleteQueryRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"dataStore" => Ok(__FieldTag::__data_store),
"data_store" => Ok(__FieldTag::__data_store),
"query" => Ok(__FieldTag::__query),
"queryModel" => Ok(__FieldTag::__query_model),
"query_model" => Ok(__FieldTag::__query_model),
"userPseudoId" => Ok(__FieldTag::__user_pseudo_id),
"user_pseudo_id" => Ok(__FieldTag::__user_pseudo_id),
"includeTailSuggestions" => Ok(__FieldTag::__include_tail_suggestions),
"include_tail_suggestions" => {
Ok(__FieldTag::__include_tail_suggestions)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CompleteQueryRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CompleteQueryRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__data_store => {
if !fields.insert(__FieldTag::__data_store) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for data_store",
));
}
result.data_store = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__query => {
if !fields.insert(__FieldTag::__query) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for query",
));
}
result.query = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__query_model => {
if !fields.insert(__FieldTag::__query_model) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for query_model",
));
}
result.query_model = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__user_pseudo_id => {
if !fields.insert(__FieldTag::__user_pseudo_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for user_pseudo_id",
));
}
result.user_pseudo_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__include_tail_suggestions => {
if !fields.insert(__FieldTag::__include_tail_suggestions) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for include_tail_suggestions",
));
}
result.include_tail_suggestions = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "completion-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::CompleteQueryResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__query_suggestions,
__tail_match_triggered,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for CompleteQueryResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"querySuggestions" => Ok(__FieldTag::__query_suggestions),
"query_suggestions" => Ok(__FieldTag::__query_suggestions),
"tailMatchTriggered" => Ok(__FieldTag::__tail_match_triggered),
"tail_match_triggered" => Ok(__FieldTag::__tail_match_triggered),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CompleteQueryResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CompleteQueryResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__query_suggestions => {
if !fields.insert(__FieldTag::__query_suggestions) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for query_suggestions",
));
}
result.query_suggestions = map
.next_value::<std::option::Option<
std::vec::Vec<
crate::model::complete_query_response::QuerySuggestion,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::__tail_match_triggered => {
if !fields.insert(__FieldTag::__tail_match_triggered) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for tail_match_triggered",
));
}
result.tail_match_triggered = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "completion-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::complete_query_response::QuerySuggestion {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__suggestion,
__completable_field_paths,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for QuerySuggestion")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"suggestion" => Ok(__FieldTag::__suggestion),
"completableFieldPaths" => Ok(__FieldTag::__completable_field_paths),
"completable_field_paths" => Ok(__FieldTag::__completable_field_paths),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::complete_query_response::QuerySuggestion;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct QuerySuggestion")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__suggestion => {
if !fields.insert(__FieldTag::__suggestion) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for suggestion",
));
}
result.suggestion = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__completable_field_paths => {
if !fields.insert(__FieldTag::__completable_field_paths) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for completable_field_paths",
));
}
result.completable_field_paths = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "control-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::Condition {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__query_terms,
__active_time_range,
__query_regex,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Condition")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"queryTerms" => Ok(__FieldTag::__query_terms),
"query_terms" => Ok(__FieldTag::__query_terms),
"activeTimeRange" => Ok(__FieldTag::__active_time_range),
"active_time_range" => Ok(__FieldTag::__active_time_range),
"queryRegex" => Ok(__FieldTag::__query_regex),
"query_regex" => Ok(__FieldTag::__query_regex),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Condition;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Condition")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__query_terms => {
if !fields.insert(__FieldTag::__query_terms) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for query_terms",
));
}
result.query_terms = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::condition::QueryTerm>,
>>()?
.unwrap_or_default();
}
__FieldTag::__active_time_range => {
if !fields.insert(__FieldTag::__active_time_range) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for active_time_range",
));
}
result.active_time_range = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::condition::TimeRange>,
>>()?
.unwrap_or_default();
}
__FieldTag::__query_regex => {
if !fields.insert(__FieldTag::__query_regex) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for query_regex",
));
}
result.query_regex = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "control-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::condition::QueryTerm {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__value,
__full_match,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for QueryTerm")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"value" => Ok(__FieldTag::__value),
"fullMatch" => Ok(__FieldTag::__full_match),
"full_match" => Ok(__FieldTag::__full_match),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::condition::QueryTerm;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct QueryTerm")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__value => {
if !fields.insert(__FieldTag::__value) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for value",
));
}
result.value = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__full_match => {
if !fields.insert(__FieldTag::__full_match) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for full_match",
));
}
result.full_match = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "control-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::condition::TimeRange {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__start_time,
__end_time,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for TimeRange")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"startTime" => Ok(__FieldTag::__start_time),
"start_time" => Ok(__FieldTag::__start_time),
"endTime" => Ok(__FieldTag::__end_time),
"end_time" => Ok(__FieldTag::__end_time),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::condition::TimeRange;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct TimeRange")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__start_time => {
if !fields.insert(__FieldTag::__start_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for start_time",
));
}
result.start_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__end_time => {
if !fields.insert(__FieldTag::__end_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for end_time",
));
}
result.end_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "control-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::Control {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__boost_action,
__filter_action,
__redirect_action,
__synonyms_action,
__promote_action,
__name,
__display_name,
__associated_serving_config_ids,
__solution_type,
__use_cases,
__conditions,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Control")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"boostAction" => Ok(__FieldTag::__boost_action),
"boost_action" => Ok(__FieldTag::__boost_action),
"filterAction" => Ok(__FieldTag::__filter_action),
"filter_action" => Ok(__FieldTag::__filter_action),
"redirectAction" => Ok(__FieldTag::__redirect_action),
"redirect_action" => Ok(__FieldTag::__redirect_action),
"synonymsAction" => Ok(__FieldTag::__synonyms_action),
"synonyms_action" => Ok(__FieldTag::__synonyms_action),
"promoteAction" => Ok(__FieldTag::__promote_action),
"promote_action" => Ok(__FieldTag::__promote_action),
"name" => Ok(__FieldTag::__name),
"displayName" => Ok(__FieldTag::__display_name),
"display_name" => Ok(__FieldTag::__display_name),
"associatedServingConfigIds" => {
Ok(__FieldTag::__associated_serving_config_ids)
}
"associated_serving_config_ids" => {
Ok(__FieldTag::__associated_serving_config_ids)
}
"solutionType" => Ok(__FieldTag::__solution_type),
"solution_type" => Ok(__FieldTag::__solution_type),
"useCases" => Ok(__FieldTag::__use_cases),
"use_cases" => Ok(__FieldTag::__use_cases),
"conditions" => Ok(__FieldTag::__conditions),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Control;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Control")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__boost_action => {
if !fields.insert(__FieldTag::__boost_action) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for boost_action",
));
}
if result.action.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `action`, a oneof with full ID .google.cloud.discoveryengine.v1.Control.boost_action, latest field was boostAction",
));
}
result.action = std::option::Option::Some(
crate::model::control::Action::BoostAction(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::control::BoostAction>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__filter_action => {
if !fields.insert(__FieldTag::__filter_action) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for filter_action",
));
}
if result.action.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `action`, a oneof with full ID .google.cloud.discoveryengine.v1.Control.filter_action, latest field was filterAction",
));
}
result.action = std::option::Option::Some(
crate::model::control::Action::FilterAction(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::control::FilterAction>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__redirect_action => {
if !fields.insert(__FieldTag::__redirect_action) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for redirect_action",
));
}
if result.action.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `action`, a oneof with full ID .google.cloud.discoveryengine.v1.Control.redirect_action, latest field was redirectAction",
));
}
result.action = std::option::Option::Some(
crate::model::control::Action::RedirectAction(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::control::RedirectAction>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__synonyms_action => {
if !fields.insert(__FieldTag::__synonyms_action) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for synonyms_action",
));
}
if result.action.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `action`, a oneof with full ID .google.cloud.discoveryengine.v1.Control.synonyms_action, latest field was synonymsAction",
));
}
result.action = std::option::Option::Some(
crate::model::control::Action::SynonymsAction(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::control::SynonymsAction>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__promote_action => {
if !fields.insert(__FieldTag::__promote_action) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for promote_action",
));
}
if result.action.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `action`, a oneof with full ID .google.cloud.discoveryengine.v1.Control.promote_action, latest field was promoteAction",
));
}
result.action = std::option::Option::Some(
crate::model::control::Action::PromoteAction(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::control::PromoteAction>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__display_name => {
if !fields.insert(__FieldTag::__display_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for display_name",
));
}
result.display_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__associated_serving_config_ids => {
if !fields.insert(__FieldTag::__associated_serving_config_ids) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for associated_serving_config_ids",
));
}
result.associated_serving_config_ids = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__solution_type => {
if !fields.insert(__FieldTag::__solution_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for solution_type",
));
}
result.solution_type = map
.next_value::<std::option::Option<crate::model::SolutionType>>()?
.unwrap_or_default();
}
__FieldTag::__use_cases => {
if !fields.insert(__FieldTag::__use_cases) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for use_cases",
));
}
result.use_cases = map.next_value::<std::option::Option<std::vec::Vec<crate::model::SearchUseCase>>>()?.unwrap_or_default();
}
__FieldTag::__conditions => {
if !fields.insert(__FieldTag::__conditions) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for conditions",
));
}
result.conditions = map.next_value::<std::option::Option<std::vec::Vec<crate::model::Condition>>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "control-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::control::BoostAction {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__fixed_boost,
__interpolation_boost_spec,
__boost,
__filter,
__data_store,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for BoostAction")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"fixedBoost" => Ok(__FieldTag::__fixed_boost),
"fixed_boost" => Ok(__FieldTag::__fixed_boost),
"interpolationBoostSpec" => Ok(__FieldTag::__interpolation_boost_spec),
"interpolation_boost_spec" => {
Ok(__FieldTag::__interpolation_boost_spec)
}
"boost" => Ok(__FieldTag::__boost),
"filter" => Ok(__FieldTag::__filter),
"dataStore" => Ok(__FieldTag::__data_store),
"data_store" => Ok(__FieldTag::__data_store),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::control::BoostAction;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BoostAction")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__fixed_boost => {
if !fields.insert(__FieldTag::__fixed_boost) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for fixed_boost",
));
}
struct __With(std::option::Option<f32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F32> >::deserialize(deserializer).map(__With)
}
}
if result.boost_spec.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `boost_spec`, a oneof with full ID .google.cloud.discoveryengine.v1.Control.BoostAction.fixed_boost, latest field was fixedBoost",
));
}
result.boost_spec = std::option::Option::Some(
crate::model::control::boost_action::BoostSpec::FixedBoost(
map.next_value::<__With>()?.0.unwrap_or_default(),
),
);
}
__FieldTag::__interpolation_boost_spec => {
if !fields.insert(__FieldTag::__interpolation_boost_spec) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for interpolation_boost_spec",
));
}
if result.boost_spec.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `boost_spec`, a oneof with full ID .google.cloud.discoveryengine.v1.Control.BoostAction.interpolation_boost_spec, latest field was interpolationBoostSpec",
));
}
result.boost_spec = std::option::Option::Some(
crate::model::control::boost_action::BoostSpec::InterpolationBoostSpec(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::control::boost_action::InterpolationBoostSpec>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__boost => {
if !fields.insert(__FieldTag::__boost) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for boost",
));
}
struct __With(std::option::Option<f32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F32> >::deserialize(deserializer).map(__With)
}
}
result.boost = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__filter => {
if !fields.insert(__FieldTag::__filter) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for filter",
));
}
result.filter = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__data_store => {
if !fields.insert(__FieldTag::__data_store) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for data_store",
));
}
result.data_store = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "control-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::control::boost_action::InterpolationBoostSpec {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__field_name,
__attribute_type,
__interpolation_type,
__control_points,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for InterpolationBoostSpec")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"fieldName" => Ok(__FieldTag::__field_name),
"field_name" => Ok(__FieldTag::__field_name),
"attributeType" => Ok(__FieldTag::__attribute_type),
"attribute_type" => Ok(__FieldTag::__attribute_type),
"interpolationType" => Ok(__FieldTag::__interpolation_type),
"interpolation_type" => Ok(__FieldTag::__interpolation_type),
"controlPoints" => Ok(__FieldTag::__control_points),
"control_points" => Ok(__FieldTag::__control_points),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::control::boost_action::InterpolationBoostSpec;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct InterpolationBoostSpec")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__field_name => {
if !fields.insert(__FieldTag::__field_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for field_name",
));
}
result.field_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__attribute_type => {
if !fields.insert(__FieldTag::__attribute_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for attribute_type",
));
}
result.attribute_type = map.next_value::<std::option::Option<crate::model::control::boost_action::interpolation_boost_spec::AttributeType>>()?.unwrap_or_default();
}
__FieldTag::__interpolation_type => {
if !fields.insert(__FieldTag::__interpolation_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for interpolation_type",
));
}
result.interpolation_type = map.next_value::<std::option::Option<crate::model::control::boost_action::interpolation_boost_spec::InterpolationType>>()?.unwrap_or_default();
}
__FieldTag::__control_points => {
if !fields.insert(__FieldTag::__control_points) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for control_points",
));
}
result.control_points = map.next_value::<std::option::Option<std::vec::Vec<crate::model::control::boost_action::interpolation_boost_spec::ControlPoint>>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "control-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::control::boost_action::interpolation_boost_spec::ControlPoint
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__attribute_value,
__boost_amount,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ControlPoint")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"attributeValue" => Ok(__FieldTag::__attribute_value),
"attribute_value" => Ok(__FieldTag::__attribute_value),
"boostAmount" => Ok(__FieldTag::__boost_amount),
"boost_amount" => Ok(__FieldTag::__boost_amount),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::control::boost_action::interpolation_boost_spec::ControlPoint;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ControlPoint")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__attribute_value => {
if !fields.insert(__FieldTag::__attribute_value) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for attribute_value",
));
}
result.attribute_value = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__boost_amount => {
if !fields.insert(__FieldTag::__boost_amount) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for boost_amount",
));
}
struct __With(std::option::Option<f32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F32> >::deserialize(deserializer).map(__With)
}
}
result.boost_amount = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "control-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::control::FilterAction {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__filter,
__data_store,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for FilterAction")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"filter" => Ok(__FieldTag::__filter),
"dataStore" => Ok(__FieldTag::__data_store),
"data_store" => Ok(__FieldTag::__data_store),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::control::FilterAction;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct FilterAction")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__filter => {
if !fields.insert(__FieldTag::__filter) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for filter",
));
}
result.filter = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__data_store => {
if !fields.insert(__FieldTag::__data_store) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for data_store",
));
}
result.data_store = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "control-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::control::RedirectAction {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__redirect_uri,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for RedirectAction")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"redirectUri" => Ok(__FieldTag::__redirect_uri),
"redirect_uri" => Ok(__FieldTag::__redirect_uri),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::control::RedirectAction;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct RedirectAction")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__redirect_uri => {
if !fields.insert(__FieldTag::__redirect_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for redirect_uri",
));
}
result.redirect_uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "control-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::control::SynonymsAction {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__synonyms,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SynonymsAction")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"synonyms" => Ok(__FieldTag::__synonyms),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::control::SynonymsAction;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SynonymsAction")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__synonyms => {
if !fields.insert(__FieldTag::__synonyms) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for synonyms",
));
}
result.synonyms = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "control-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::control::PromoteAction {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__data_store,
__search_link_promotion,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for PromoteAction")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"dataStore" => Ok(__FieldTag::__data_store),
"data_store" => Ok(__FieldTag::__data_store),
"searchLinkPromotion" => Ok(__FieldTag::__search_link_promotion),
"search_link_promotion" => Ok(__FieldTag::__search_link_promotion),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::control::PromoteAction;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct PromoteAction")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__data_store => {
if !fields.insert(__FieldTag::__data_store) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for data_store",
));
}
result.data_store = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__search_link_promotion => {
if !fields.insert(__FieldTag::__search_link_promotion) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for search_link_promotion",
));
}
result.search_link_promotion = map.next_value::<std::option::Option<crate::model::SearchLinkPromotion>>()?
;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "control-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::CreateControlRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__parent,
__control,
__control_id,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for CreateControlRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"parent" => Ok(__FieldTag::__parent),
"control" => Ok(__FieldTag::__control),
"controlId" => Ok(__FieldTag::__control_id),
"control_id" => Ok(__FieldTag::__control_id),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CreateControlRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CreateControlRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__control => {
if !fields.insert(__FieldTag::__control) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for control",
));
}
result.control =
map.next_value::<std::option::Option<crate::model::Control>>()?;
}
__FieldTag::__control_id => {
if !fields.insert(__FieldTag::__control_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for control_id",
));
}
result.control_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "control-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::UpdateControlRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__control,
__update_mask,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for UpdateControlRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"control" => Ok(__FieldTag::__control),
"updateMask" => Ok(__FieldTag::__update_mask),
"update_mask" => Ok(__FieldTag::__update_mask),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::UpdateControlRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct UpdateControlRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__control => {
if !fields.insert(__FieldTag::__control) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for control",
));
}
result.control =
map.next_value::<std::option::Option<crate::model::Control>>()?;
}
__FieldTag::__update_mask => {
if !fields.insert(__FieldTag::__update_mask) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_mask",
));
}
result.update_mask =
map.next_value::<std::option::Option<wkt::FieldMask>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "control-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::DeleteControlRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DeleteControlRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DeleteControlRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DeleteControlRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "control-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::GetControlRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for GetControlRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::GetControlRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GetControlRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "control-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ListControlsRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__parent,
__page_size,
__page_token,
__filter,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ListControlsRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"parent" => Ok(__FieldTag::__parent),
"pageSize" => Ok(__FieldTag::__page_size),
"page_size" => Ok(__FieldTag::__page_size),
"pageToken" => Ok(__FieldTag::__page_token),
"page_token" => Ok(__FieldTag::__page_token),
"filter" => Ok(__FieldTag::__filter),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListControlsRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListControlsRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__page_size => {
if !fields.insert(__FieldTag::__page_size) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_size",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.page_size = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__page_token => {
if !fields.insert(__FieldTag::__page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_token",
));
}
result.page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__filter => {
if !fields.insert(__FieldTag::__filter) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for filter",
));
}
result.filter = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "control-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ListControlsResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__controls,
__next_page_token,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ListControlsResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"controls" => Ok(__FieldTag::__controls),
"nextPageToken" => Ok(__FieldTag::__next_page_token),
"next_page_token" => Ok(__FieldTag::__next_page_token),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListControlsResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListControlsResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__controls => {
if !fields.insert(__FieldTag::__controls) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for controls",
));
}
result.controls = map.next_value::<std::option::Option<std::vec::Vec<crate::model::Control>>>()?.unwrap_or_default();
}
__FieldTag::__next_page_token => {
if !fields.insert(__FieldTag::__next_page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for next_page_token",
));
}
result.next_page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "conversational-search-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::Conversation {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
__state,
__user_pseudo_id,
__messages,
__start_time,
__end_time,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Conversation")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
"state" => Ok(__FieldTag::__state),
"userPseudoId" => Ok(__FieldTag::__user_pseudo_id),
"user_pseudo_id" => Ok(__FieldTag::__user_pseudo_id),
"messages" => Ok(__FieldTag::__messages),
"startTime" => Ok(__FieldTag::__start_time),
"start_time" => Ok(__FieldTag::__start_time),
"endTime" => Ok(__FieldTag::__end_time),
"end_time" => Ok(__FieldTag::__end_time),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Conversation;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Conversation")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__state => {
if !fields.insert(__FieldTag::__state) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for state",
));
}
result.state = map.next_value::<std::option::Option<crate::model::conversation::State>>()?.unwrap_or_default();
}
__FieldTag::__user_pseudo_id => {
if !fields.insert(__FieldTag::__user_pseudo_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for user_pseudo_id",
));
}
result.user_pseudo_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__messages => {
if !fields.insert(__FieldTag::__messages) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for messages",
));
}
result.messages = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::ConversationMessage>,
>>()?
.unwrap_or_default();
}
__FieldTag::__start_time => {
if !fields.insert(__FieldTag::__start_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for start_time",
));
}
result.start_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__end_time => {
if !fields.insert(__FieldTag::__end_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for end_time",
));
}
result.end_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "conversational-search-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::Reply {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__summary,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Reply")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"summary" => Ok(__FieldTag::__summary),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Reply;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Reply")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__summary => {
if !fields.insert(__FieldTag::__summary) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for summary",
));
}
result.summary = map.next_value::<std::option::Option<crate::model::search_response::Summary>>()?
;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "conversational-search-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ConversationContext {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__context_documents,
__active_document,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ConversationContext")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"contextDocuments" => Ok(__FieldTag::__context_documents),
"context_documents" => Ok(__FieldTag::__context_documents),
"activeDocument" => Ok(__FieldTag::__active_document),
"active_document" => Ok(__FieldTag::__active_document),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ConversationContext;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ConversationContext")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__context_documents => {
if !fields.insert(__FieldTag::__context_documents) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for context_documents",
));
}
result.context_documents = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__active_document => {
if !fields.insert(__FieldTag::__active_document) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for active_document",
));
}
result.active_document = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "conversational-search-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::TextInput {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__input,
__context,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for TextInput")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"input" => Ok(__FieldTag::__input),
"context" => Ok(__FieldTag::__context),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::TextInput;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct TextInput")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__input => {
if !fields.insert(__FieldTag::__input) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for input",
));
}
result.input = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__context => {
if !fields.insert(__FieldTag::__context) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for context",
));
}
result.context = map.next_value::<std::option::Option<crate::model::ConversationContext>>()?
;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "conversational-search-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ConversationMessage {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__user_input,
__reply,
__create_time,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ConversationMessage")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"userInput" => Ok(__FieldTag::__user_input),
"user_input" => Ok(__FieldTag::__user_input),
"reply" => Ok(__FieldTag::__reply),
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ConversationMessage;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ConversationMessage")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__user_input => {
if !fields.insert(__FieldTag::__user_input) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for user_input",
));
}
if result.message.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `message`, a oneof with full ID .google.cloud.discoveryengine.v1.ConversationMessage.user_input, latest field was userInput",
));
}
result.message = std::option::Option::Some(
crate::model::conversation_message::Message::UserInput(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::TextInput>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__reply => {
if !fields.insert(__FieldTag::__reply) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for reply",
));
}
if result.message.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `message`, a oneof with full ID .google.cloud.discoveryengine.v1.ConversationMessage.reply, latest field was reply",
));
}
result.message =
std::option::Option::Some(
crate::model::conversation_message::Message::Reply(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::Reply>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "conversational-search-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ConverseConversationRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
__query,
__serving_config,
__conversation,
__safe_search,
__user_labels,
__summary_spec,
__filter,
__boost_spec,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ConverseConversationRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
"query" => Ok(__FieldTag::__query),
"servingConfig" => Ok(__FieldTag::__serving_config),
"serving_config" => Ok(__FieldTag::__serving_config),
"conversation" => Ok(__FieldTag::__conversation),
"safeSearch" => Ok(__FieldTag::__safe_search),
"safe_search" => Ok(__FieldTag::__safe_search),
"userLabels" => Ok(__FieldTag::__user_labels),
"user_labels" => Ok(__FieldTag::__user_labels),
"summarySpec" => Ok(__FieldTag::__summary_spec),
"summary_spec" => Ok(__FieldTag::__summary_spec),
"filter" => Ok(__FieldTag::__filter),
"boostSpec" => Ok(__FieldTag::__boost_spec),
"boost_spec" => Ok(__FieldTag::__boost_spec),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ConverseConversationRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ConverseConversationRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__query => {
if !fields.insert(__FieldTag::__query) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for query",
));
}
result.query =
map.next_value::<std::option::Option<crate::model::TextInput>>()?;
}
__FieldTag::__serving_config => {
if !fields.insert(__FieldTag::__serving_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for serving_config",
));
}
result.serving_config = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__conversation => {
if !fields.insert(__FieldTag::__conversation) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for conversation",
));
}
result.conversation = map
.next_value::<std::option::Option<crate::model::Conversation>>()?;
}
__FieldTag::__safe_search => {
if !fields.insert(__FieldTag::__safe_search) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for safe_search",
));
}
result.safe_search = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__user_labels => {
if !fields.insert(__FieldTag::__user_labels) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for user_labels",
));
}
result.user_labels = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
std::string::String,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::__summary_spec => {
if !fields.insert(__FieldTag::__summary_spec) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for summary_spec",
));
}
result.summary_spec = map.next_value::<std::option::Option<
crate::model::search_request::content_search_spec::SummarySpec,
>>()?;
}
__FieldTag::__filter => {
if !fields.insert(__FieldTag::__filter) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for filter",
));
}
result.filter = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__boost_spec => {
if !fields.insert(__FieldTag::__boost_spec) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for boost_spec",
));
}
result.boost_spec = map.next_value::<std::option::Option<crate::model::search_request::BoostSpec>>()?
;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "conversational-search-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ConverseConversationResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__reply,
__conversation,
__search_results,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ConverseConversationResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"reply" => Ok(__FieldTag::__reply),
"conversation" => Ok(__FieldTag::__conversation),
"searchResults" => Ok(__FieldTag::__search_results),
"search_results" => Ok(__FieldTag::__search_results),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ConverseConversationResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ConverseConversationResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__reply => {
if !fields.insert(__FieldTag::__reply) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for reply",
));
}
result.reply =
map.next_value::<std::option::Option<crate::model::Reply>>()?;
}
__FieldTag::__conversation => {
if !fields.insert(__FieldTag::__conversation) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for conversation",
));
}
result.conversation = map
.next_value::<std::option::Option<crate::model::Conversation>>()?;
}
__FieldTag::__search_results => {
if !fields.insert(__FieldTag::__search_results) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for search_results",
));
}
result.search_results = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::search_response::SearchResult>,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "conversational-search-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::CreateConversationRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__parent,
__conversation,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for CreateConversationRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"parent" => Ok(__FieldTag::__parent),
"conversation" => Ok(__FieldTag::__conversation),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CreateConversationRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CreateConversationRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__conversation => {
if !fields.insert(__FieldTag::__conversation) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for conversation",
));
}
result.conversation = map
.next_value::<std::option::Option<crate::model::Conversation>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "conversational-search-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::UpdateConversationRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__conversation,
__update_mask,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for UpdateConversationRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"conversation" => Ok(__FieldTag::__conversation),
"updateMask" => Ok(__FieldTag::__update_mask),
"update_mask" => Ok(__FieldTag::__update_mask),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::UpdateConversationRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct UpdateConversationRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__conversation => {
if !fields.insert(__FieldTag::__conversation) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for conversation",
));
}
result.conversation = map
.next_value::<std::option::Option<crate::model::Conversation>>()?;
}
__FieldTag::__update_mask => {
if !fields.insert(__FieldTag::__update_mask) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_mask",
));
}
result.update_mask =
map.next_value::<std::option::Option<wkt::FieldMask>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "conversational-search-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::DeleteConversationRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DeleteConversationRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DeleteConversationRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DeleteConversationRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "conversational-search-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::GetConversationRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for GetConversationRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::GetConversationRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GetConversationRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "conversational-search-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ListConversationsRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__parent,
__page_size,
__page_token,
__filter,
__order_by,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ListConversationsRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"parent" => Ok(__FieldTag::__parent),
"pageSize" => Ok(__FieldTag::__page_size),
"page_size" => Ok(__FieldTag::__page_size),
"pageToken" => Ok(__FieldTag::__page_token),
"page_token" => Ok(__FieldTag::__page_token),
"filter" => Ok(__FieldTag::__filter),
"orderBy" => Ok(__FieldTag::__order_by),
"order_by" => Ok(__FieldTag::__order_by),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListConversationsRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListConversationsRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__page_size => {
if !fields.insert(__FieldTag::__page_size) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_size",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.page_size = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__page_token => {
if !fields.insert(__FieldTag::__page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_token",
));
}
result.page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__filter => {
if !fields.insert(__FieldTag::__filter) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for filter",
));
}
result.filter = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__order_by => {
if !fields.insert(__FieldTag::__order_by) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for order_by",
));
}
result.order_by = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "conversational-search-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ListConversationsResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__conversations,
__next_page_token,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ListConversationsResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"conversations" => Ok(__FieldTag::__conversations),
"nextPageToken" => Ok(__FieldTag::__next_page_token),
"next_page_token" => Ok(__FieldTag::__next_page_token),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListConversationsResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListConversationsResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__conversations => {
if !fields.insert(__FieldTag::__conversations) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for conversations",
));
}
result.conversations = map.next_value::<std::option::Option<std::vec::Vec<crate::model::Conversation>>>()?.unwrap_or_default();
}
__FieldTag::__next_page_token => {
if !fields.insert(__FieldTag::__next_page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for next_page_token",
));
}
result.next_page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "conversational-search-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::AnswerQueryRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__serving_config,
__query,
__session,
__safety_spec,
__related_questions_spec,
__grounding_spec,
__answer_generation_spec,
__search_spec,
__query_understanding_spec,
__asynchronous_mode,
__user_pseudo_id,
__user_labels,
__end_user_spec,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for AnswerQueryRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"servingConfig" => Ok(__FieldTag::__serving_config),
"serving_config" => Ok(__FieldTag::__serving_config),
"query" => Ok(__FieldTag::__query),
"session" => Ok(__FieldTag::__session),
"safetySpec" => Ok(__FieldTag::__safety_spec),
"safety_spec" => Ok(__FieldTag::__safety_spec),
"relatedQuestionsSpec" => Ok(__FieldTag::__related_questions_spec),
"related_questions_spec" => Ok(__FieldTag::__related_questions_spec),
"groundingSpec" => Ok(__FieldTag::__grounding_spec),
"grounding_spec" => Ok(__FieldTag::__grounding_spec),
"answerGenerationSpec" => Ok(__FieldTag::__answer_generation_spec),
"answer_generation_spec" => Ok(__FieldTag::__answer_generation_spec),
"searchSpec" => Ok(__FieldTag::__search_spec),
"search_spec" => Ok(__FieldTag::__search_spec),
"queryUnderstandingSpec" => Ok(__FieldTag::__query_understanding_spec),
"query_understanding_spec" => {
Ok(__FieldTag::__query_understanding_spec)
}
"asynchronousMode" => Ok(__FieldTag::__asynchronous_mode),
"asynchronous_mode" => Ok(__FieldTag::__asynchronous_mode),
"userPseudoId" => Ok(__FieldTag::__user_pseudo_id),
"user_pseudo_id" => Ok(__FieldTag::__user_pseudo_id),
"userLabels" => Ok(__FieldTag::__user_labels),
"user_labels" => Ok(__FieldTag::__user_labels),
"endUserSpec" => Ok(__FieldTag::__end_user_spec),
"end_user_spec" => Ok(__FieldTag::__end_user_spec),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::AnswerQueryRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct AnswerQueryRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__serving_config => {
if !fields.insert(__FieldTag::__serving_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for serving_config",
));
}
result.serving_config = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__query => {
if !fields.insert(__FieldTag::__query) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for query",
));
}
result.query =
map.next_value::<std::option::Option<crate::model::Query>>()?;
}
__FieldTag::__session => {
if !fields.insert(__FieldTag::__session) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for session",
));
}
result.session = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__safety_spec => {
if !fields.insert(__FieldTag::__safety_spec) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for safety_spec",
));
}
result.safety_spec = map.next_value::<std::option::Option<
crate::model::answer_query_request::SafetySpec,
>>()?;
}
__FieldTag::__related_questions_spec => {
if !fields.insert(__FieldTag::__related_questions_spec) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for related_questions_spec",
));
}
result.related_questions_spec = map.next_value::<std::option::Option<
crate::model::answer_query_request::RelatedQuestionsSpec,
>>()?;
}
__FieldTag::__grounding_spec => {
if !fields.insert(__FieldTag::__grounding_spec) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for grounding_spec",
));
}
result.grounding_spec = map.next_value::<std::option::Option<
crate::model::answer_query_request::GroundingSpec,
>>()?;
}
__FieldTag::__answer_generation_spec => {
if !fields.insert(__FieldTag::__answer_generation_spec) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for answer_generation_spec",
));
}
result.answer_generation_spec = map.next_value::<std::option::Option<
crate::model::answer_query_request::AnswerGenerationSpec,
>>()?;
}
__FieldTag::__search_spec => {
if !fields.insert(__FieldTag::__search_spec) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for search_spec",
));
}
result.search_spec = map.next_value::<std::option::Option<
crate::model::answer_query_request::SearchSpec,
>>()?;
}
__FieldTag::__query_understanding_spec => {
if !fields.insert(__FieldTag::__query_understanding_spec) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for query_understanding_spec",
));
}
result.query_understanding_spec = map
.next_value::<std::option::Option<
crate::model::answer_query_request::QueryUnderstandingSpec,
>>()?;
}
__FieldTag::__asynchronous_mode => {
if !fields.insert(__FieldTag::__asynchronous_mode) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for asynchronous_mode",
));
}
result.asynchronous_mode = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__user_pseudo_id => {
if !fields.insert(__FieldTag::__user_pseudo_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for user_pseudo_id",
));
}
result.user_pseudo_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__user_labels => {
if !fields.insert(__FieldTag::__user_labels) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for user_labels",
));
}
result.user_labels = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
std::string::String,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::__end_user_spec => {
if !fields.insert(__FieldTag::__end_user_spec) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for end_user_spec",
));
}
result.end_user_spec = map.next_value::<std::option::Option<
crate::model::answer_query_request::EndUserSpec,
>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "conversational-search-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::answer_query_request::SafetySpec {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__enable,
__safety_settings,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SafetySpec")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"enable" => Ok(__FieldTag::__enable),
"safetySettings" => Ok(__FieldTag::__safety_settings),
"safety_settings" => Ok(__FieldTag::__safety_settings),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::answer_query_request::SafetySpec;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SafetySpec")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__enable => {
if !fields.insert(__FieldTag::__enable) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for enable",
));
}
result.enable = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__safety_settings => {
if !fields.insert(__FieldTag::__safety_settings) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for safety_settings",
));
}
result.safety_settings = map.next_value::<std::option::Option<std::vec::Vec<crate::model::answer_query_request::safety_spec::SafetySetting>>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "conversational-search-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::answer_query_request::safety_spec::SafetySetting {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__category,
__threshold,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SafetySetting")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"category" => Ok(__FieldTag::__category),
"threshold" => Ok(__FieldTag::__threshold),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::answer_query_request::safety_spec::SafetySetting;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SafetySetting")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__category => {
if !fields.insert(__FieldTag::__category) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for category",
));
}
result.category = map
.next_value::<std::option::Option<crate::model::HarmCategory>>()?
.unwrap_or_default();
}
__FieldTag::__threshold => {
if !fields.insert(__FieldTag::__threshold) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for threshold",
));
}
result.threshold = map.next_value::<std::option::Option<crate::model::answer_query_request::safety_spec::safety_setting::HarmBlockThreshold>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "conversational-search-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::answer_query_request::RelatedQuestionsSpec {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__enable,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for RelatedQuestionsSpec")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"enable" => Ok(__FieldTag::__enable),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::answer_query_request::RelatedQuestionsSpec;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct RelatedQuestionsSpec")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__enable => {
if !fields.insert(__FieldTag::__enable) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for enable",
));
}
result.enable = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "conversational-search-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::answer_query_request::GroundingSpec {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__include_grounding_supports,
__filtering_level,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for GroundingSpec")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"includeGroundingSupports" => {
Ok(__FieldTag::__include_grounding_supports)
}
"include_grounding_supports" => {
Ok(__FieldTag::__include_grounding_supports)
}
"filteringLevel" => Ok(__FieldTag::__filtering_level),
"filtering_level" => Ok(__FieldTag::__filtering_level),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::answer_query_request::GroundingSpec;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GroundingSpec")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__include_grounding_supports => {
if !fields.insert(__FieldTag::__include_grounding_supports) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for include_grounding_supports",
));
}
result.include_grounding_supports = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__filtering_level => {
if !fields.insert(__FieldTag::__filtering_level) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for filtering_level",
));
}
result.filtering_level = map.next_value::<std::option::Option<crate::model::answer_query_request::grounding_spec::FilteringLevel>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "conversational-search-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::answer_query_request::AnswerGenerationSpec {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__model_spec,
__prompt_spec,
__include_citations,
__answer_language_code,
__ignore_adversarial_query,
__ignore_non_answer_seeking_query,
__ignore_low_relevant_content,
__ignore_jail_breaking_query,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for AnswerGenerationSpec")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"modelSpec" => Ok(__FieldTag::__model_spec),
"model_spec" => Ok(__FieldTag::__model_spec),
"promptSpec" => Ok(__FieldTag::__prompt_spec),
"prompt_spec" => Ok(__FieldTag::__prompt_spec),
"includeCitations" => Ok(__FieldTag::__include_citations),
"include_citations" => Ok(__FieldTag::__include_citations),
"answerLanguageCode" => Ok(__FieldTag::__answer_language_code),
"answer_language_code" => Ok(__FieldTag::__answer_language_code),
"ignoreAdversarialQuery" => Ok(__FieldTag::__ignore_adversarial_query),
"ignore_adversarial_query" => {
Ok(__FieldTag::__ignore_adversarial_query)
}
"ignoreNonAnswerSeekingQuery" => {
Ok(__FieldTag::__ignore_non_answer_seeking_query)
}
"ignore_non_answer_seeking_query" => {
Ok(__FieldTag::__ignore_non_answer_seeking_query)
}
"ignoreLowRelevantContent" => {
Ok(__FieldTag::__ignore_low_relevant_content)
}
"ignore_low_relevant_content" => {
Ok(__FieldTag::__ignore_low_relevant_content)
}
"ignoreJailBreakingQuery" => {
Ok(__FieldTag::__ignore_jail_breaking_query)
}
"ignore_jail_breaking_query" => {
Ok(__FieldTag::__ignore_jail_breaking_query)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::answer_query_request::AnswerGenerationSpec;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct AnswerGenerationSpec")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__model_spec => {
if !fields.insert(__FieldTag::__model_spec) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for model_spec",
));
}
result.model_spec = map.next_value::<std::option::Option<crate::model::answer_query_request::answer_generation_spec::ModelSpec>>()?
;
}
__FieldTag::__prompt_spec => {
if !fields.insert(__FieldTag::__prompt_spec) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for prompt_spec",
));
}
result.prompt_spec = map.next_value::<std::option::Option<crate::model::answer_query_request::answer_generation_spec::PromptSpec>>()?
;
}
__FieldTag::__include_citations => {
if !fields.insert(__FieldTag::__include_citations) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for include_citations",
));
}
result.include_citations = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__answer_language_code => {
if !fields.insert(__FieldTag::__answer_language_code) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for answer_language_code",
));
}
result.answer_language_code = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__ignore_adversarial_query => {
if !fields.insert(__FieldTag::__ignore_adversarial_query) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for ignore_adversarial_query",
));
}
result.ignore_adversarial_query = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__ignore_non_answer_seeking_query => {
if !fields.insert(__FieldTag::__ignore_non_answer_seeking_query) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for ignore_non_answer_seeking_query",
));
}
result.ignore_non_answer_seeking_query = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__ignore_low_relevant_content => {
if !fields.insert(__FieldTag::__ignore_low_relevant_content) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for ignore_low_relevant_content",
));
}
result.ignore_low_relevant_content =
map.next_value::<std::option::Option<bool>>()?;
}
__FieldTag::__ignore_jail_breaking_query => {
if !fields.insert(__FieldTag::__ignore_jail_breaking_query) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for ignore_jail_breaking_query",
));
}
result.ignore_jail_breaking_query = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "conversational-search-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::answer_query_request::answer_generation_spec::ModelSpec
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__model_version,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ModelSpec")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"modelVersion" => Ok(__FieldTag::__model_version),
"model_version" => Ok(__FieldTag::__model_version),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::answer_query_request::answer_generation_spec::ModelSpec;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ModelSpec")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__model_version => {
if !fields.insert(__FieldTag::__model_version) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for model_version",
));
}
result.model_version = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "conversational-search-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::answer_query_request::answer_generation_spec::PromptSpec
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__preamble,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for PromptSpec")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"preamble" => Ok(__FieldTag::__preamble),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::answer_query_request::answer_generation_spec::PromptSpec;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct PromptSpec")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__preamble => {
if !fields.insert(__FieldTag::__preamble) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for preamble",
));
}
result.preamble = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "conversational-search-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::answer_query_request::SearchSpec {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__search_params,
__search_result_list,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SearchSpec")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"searchParams" => Ok(__FieldTag::__search_params),
"search_params" => Ok(__FieldTag::__search_params),
"searchResultList" => Ok(__FieldTag::__search_result_list),
"search_result_list" => Ok(__FieldTag::__search_result_list),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::answer_query_request::SearchSpec;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SearchSpec")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__search_params => {
if !fields.insert(__FieldTag::__search_params) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for search_params",
));
}
if result.input.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `input`, a oneof with full ID .google.cloud.discoveryengine.v1.AnswerQueryRequest.SearchSpec.search_params, latest field was searchParams",
));
}
result.input = std::option::Option::Some(
crate::model::answer_query_request::search_spec::Input::SearchParams(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::answer_query_request::search_spec::SearchParams>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__search_result_list => {
if !fields.insert(__FieldTag::__search_result_list) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for search_result_list",
));
}
if result.input.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `input`, a oneof with full ID .google.cloud.discoveryengine.v1.AnswerQueryRequest.SearchSpec.search_result_list, latest field was searchResultList",
));
}
result.input = std::option::Option::Some(
crate::model::answer_query_request::search_spec::Input::SearchResultList(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::answer_query_request::search_spec::SearchResultList>>>()?.unwrap_or_default()
),
);
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "conversational-search-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::answer_query_request::search_spec::SearchParams {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__max_return_results,
__filter,
__boost_spec,
__order_by,
__search_result_mode,
__data_store_specs,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SearchParams")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"maxReturnResults" => Ok(__FieldTag::__max_return_results),
"max_return_results" => Ok(__FieldTag::__max_return_results),
"filter" => Ok(__FieldTag::__filter),
"boostSpec" => Ok(__FieldTag::__boost_spec),
"boost_spec" => Ok(__FieldTag::__boost_spec),
"orderBy" => Ok(__FieldTag::__order_by),
"order_by" => Ok(__FieldTag::__order_by),
"searchResultMode" => Ok(__FieldTag::__search_result_mode),
"search_result_mode" => Ok(__FieldTag::__search_result_mode),
"dataStoreSpecs" => Ok(__FieldTag::__data_store_specs),
"data_store_specs" => Ok(__FieldTag::__data_store_specs),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::answer_query_request::search_spec::SearchParams;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SearchParams")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__max_return_results => {
if !fields.insert(__FieldTag::__max_return_results) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for max_return_results",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.max_return_results =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__filter => {
if !fields.insert(__FieldTag::__filter) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for filter",
));
}
result.filter = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__boost_spec => {
if !fields.insert(__FieldTag::__boost_spec) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for boost_spec",
));
}
result.boost_spec = map.next_value::<std::option::Option<crate::model::search_request::BoostSpec>>()?
;
}
__FieldTag::__order_by => {
if !fields.insert(__FieldTag::__order_by) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for order_by",
));
}
result.order_by = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__search_result_mode => {
if !fields.insert(__FieldTag::__search_result_mode) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for search_result_mode",
));
}
result.search_result_mode = map.next_value::<std::option::Option<crate::model::search_request::content_search_spec::SearchResultMode>>()?.unwrap_or_default();
}
__FieldTag::__data_store_specs => {
if !fields.insert(__FieldTag::__data_store_specs) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for data_store_specs",
));
}
result.data_store_specs = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::search_request::DataStoreSpec>,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "conversational-search-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::answer_query_request::search_spec::SearchResultList
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__search_results,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SearchResultList")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"searchResults" => Ok(__FieldTag::__search_results),
"search_results" => Ok(__FieldTag::__search_results),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::answer_query_request::search_spec::SearchResultList;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SearchResultList")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__search_results => {
if !fields.insert(__FieldTag::__search_results) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for search_results",
));
}
result.search_results = map.next_value::<std::option::Option<std::vec::Vec<crate::model::answer_query_request::search_spec::search_result_list::SearchResult>>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "conversational-search-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::answer_query_request::search_spec::search_result_list::SearchResult
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__unstructured_document_info,
__chunk_info,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SearchResult")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"unstructuredDocumentInfo" => {
Ok(__FieldTag::__unstructured_document_info)
}
"unstructured_document_info" => {
Ok(__FieldTag::__unstructured_document_info)
}
"chunkInfo" => Ok(__FieldTag::__chunk_info),
"chunk_info" => Ok(__FieldTag::__chunk_info),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::answer_query_request::search_spec::search_result_list::SearchResult;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SearchResult")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__unstructured_document_info => {
if !fields.insert(__FieldTag::__unstructured_document_info) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for unstructured_document_info",
));
}
if result.content.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `content`, a oneof with full ID .google.cloud.discoveryengine.v1.AnswerQueryRequest.SearchSpec.SearchResultList.SearchResult.unstructured_document_info, latest field was unstructuredDocumentInfo",
));
}
result.content = std::option::Option::Some(
crate::model::answer_query_request::search_spec::search_result_list::search_result::Content::UnstructuredDocumentInfo(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::answer_query_request::search_spec::search_result_list::search_result::UnstructuredDocumentInfo>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__chunk_info => {
if !fields.insert(__FieldTag::__chunk_info) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for chunk_info",
));
}
if result.content.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `content`, a oneof with full ID .google.cloud.discoveryengine.v1.AnswerQueryRequest.SearchSpec.SearchResultList.SearchResult.chunk_info, latest field was chunkInfo",
));
}
result.content = std::option::Option::Some(
crate::model::answer_query_request::search_spec::search_result_list::search_result::Content::ChunkInfo(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::answer_query_request::search_spec::search_result_list::search_result::ChunkInfo>>>()?.unwrap_or_default()
),
);
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "conversational-search-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::answer_query_request::search_spec::search_result_list::search_result::UnstructuredDocumentInfo {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__document,
__uri,
__title,
__document_contexts,
__extractive_segments,
__extractive_answers,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for UnstructuredDocumentInfo")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"document" => Ok(__FieldTag::__document),
"uri" => Ok(__FieldTag::__uri),
"title" => Ok(__FieldTag::__title),
"documentContexts" => Ok(__FieldTag::__document_contexts),
"document_contexts" => Ok(__FieldTag::__document_contexts),
"extractiveSegments" => Ok(__FieldTag::__extractive_segments),
"extractive_segments" => Ok(__FieldTag::__extractive_segments),
"extractiveAnswers" => Ok(__FieldTag::__extractive_answers),
"extractive_answers" => Ok(__FieldTag::__extractive_answers),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::answer_query_request::search_spec::search_result_list::search_result::UnstructuredDocumentInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct UnstructuredDocumentInfo")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
use std::option::Option::Some;
#[allow(unused_imports)]
use serde::de::Error;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__document => {
if !fields.insert(__FieldTag::__document) {
return std::result::Result::Err(A::Error::duplicate_field("multiple values for document"));
}
result.document = map.next_value::<std::option::Option<std::string::String>>()?.unwrap_or_default();
},
__FieldTag::__uri => {
if !fields.insert(__FieldTag::__uri) {
return std::result::Result::Err(A::Error::duplicate_field("multiple values for uri"));
}
result.uri = map.next_value::<std::option::Option<std::string::String>>()?.unwrap_or_default();
},
__FieldTag::__title => {
if !fields.insert(__FieldTag::__title) {
return std::result::Result::Err(A::Error::duplicate_field("multiple values for title"));
}
result.title = map.next_value::<std::option::Option<std::string::String>>()?.unwrap_or_default();
},
__FieldTag::__document_contexts => {
if !fields.insert(__FieldTag::__document_contexts) {
return std::result::Result::Err(A::Error::duplicate_field("multiple values for document_contexts"));
}
result.document_contexts = map.next_value::<std::option::Option<std::vec::Vec<crate::model::answer_query_request::search_spec::search_result_list::search_result::unstructured_document_info::DocumentContext>>>()?.unwrap_or_default();
},
__FieldTag::__extractive_segments => {
if !fields.insert(__FieldTag::__extractive_segments) {
return std::result::Result::Err(A::Error::duplicate_field("multiple values for extractive_segments"));
}
result.extractive_segments = map.next_value::<std::option::Option<std::vec::Vec<crate::model::answer_query_request::search_spec::search_result_list::search_result::unstructured_document_info::ExtractiveSegment>>>()?.unwrap_or_default();
},
__FieldTag::__extractive_answers => {
if !fields.insert(__FieldTag::__extractive_answers) {
return std::result::Result::Err(A::Error::duplicate_field("multiple values for extractive_answers"));
}
result.extractive_answers = map.next_value::<std::option::Option<std::vec::Vec<crate::model::answer_query_request::search_spec::search_result_list::search_result::unstructured_document_info::ExtractiveAnswer>>>()?.unwrap_or_default();
},
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
},
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "conversational-search-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::answer_query_request::search_spec::search_result_list::search_result::unstructured_document_info::DocumentContext {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__page_identifier,
__content,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DocumentContext")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"pageIdentifier" => Ok(__FieldTag::__page_identifier),
"page_identifier" => Ok(__FieldTag::__page_identifier),
"content" => Ok(__FieldTag::__content),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::answer_query_request::search_spec::search_result_list::search_result::unstructured_document_info::DocumentContext;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DocumentContext")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
use std::option::Option::Some;
#[allow(unused_imports)]
use serde::de::Error;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__page_identifier => {
if !fields.insert(__FieldTag::__page_identifier) {
return std::result::Result::Err(A::Error::duplicate_field("multiple values for page_identifier"));
}
result.page_identifier = map.next_value::<std::option::Option<std::string::String>>()?.unwrap_or_default();
},
__FieldTag::__content => {
if !fields.insert(__FieldTag::__content) {
return std::result::Result::Err(A::Error::duplicate_field("multiple values for content"));
}
result.content = map.next_value::<std::option::Option<std::string::String>>()?.unwrap_or_default();
},
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
},
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "conversational-search-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::answer_query_request::search_spec::search_result_list::search_result::unstructured_document_info::ExtractiveSegment {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__page_identifier,
__content,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ExtractiveSegment")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"pageIdentifier" => Ok(__FieldTag::__page_identifier),
"page_identifier" => Ok(__FieldTag::__page_identifier),
"content" => Ok(__FieldTag::__content),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::answer_query_request::search_spec::search_result_list::search_result::unstructured_document_info::ExtractiveSegment;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ExtractiveSegment")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
use std::option::Option::Some;
#[allow(unused_imports)]
use serde::de::Error;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__page_identifier => {
if !fields.insert(__FieldTag::__page_identifier) {
return std::result::Result::Err(A::Error::duplicate_field("multiple values for page_identifier"));
}
result.page_identifier = map.next_value::<std::option::Option<std::string::String>>()?.unwrap_or_default();
},
__FieldTag::__content => {
if !fields.insert(__FieldTag::__content) {
return std::result::Result::Err(A::Error::duplicate_field("multiple values for content"));
}
result.content = map.next_value::<std::option::Option<std::string::String>>()?.unwrap_or_default();
},
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
},
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "conversational-search-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::answer_query_request::search_spec::search_result_list::search_result::unstructured_document_info::ExtractiveAnswer {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__page_identifier,
__content,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ExtractiveAnswer")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"pageIdentifier" => Ok(__FieldTag::__page_identifier),
"page_identifier" => Ok(__FieldTag::__page_identifier),
"content" => Ok(__FieldTag::__content),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::answer_query_request::search_spec::search_result_list::search_result::unstructured_document_info::ExtractiveAnswer;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ExtractiveAnswer")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
use std::option::Option::Some;
#[allow(unused_imports)]
use serde::de::Error;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__page_identifier => {
if !fields.insert(__FieldTag::__page_identifier) {
return std::result::Result::Err(A::Error::duplicate_field("multiple values for page_identifier"));
}
result.page_identifier = map.next_value::<std::option::Option<std::string::String>>()?.unwrap_or_default();
},
__FieldTag::__content => {
if !fields.insert(__FieldTag::__content) {
return std::result::Result::Err(A::Error::duplicate_field("multiple values for content"));
}
result.content = map.next_value::<std::option::Option<std::string::String>>()?.unwrap_or_default();
},
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
},
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "conversational-search-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::answer_query_request::search_spec::search_result_list::search_result::ChunkInfo
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__chunk,
__content,
__document_metadata,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ChunkInfo")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"chunk" => Ok(__FieldTag::__chunk),
"content" => Ok(__FieldTag::__content),
"documentMetadata" => Ok(__FieldTag::__document_metadata),
"document_metadata" => Ok(__FieldTag::__document_metadata),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::answer_query_request::search_spec::search_result_list::search_result::ChunkInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ChunkInfo")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__chunk => {
if !fields.insert(__FieldTag::__chunk) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for chunk",
));
}
result.chunk = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__content => {
if !fields.insert(__FieldTag::__content) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for content",
));
}
result.content = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__document_metadata => {
if !fields.insert(__FieldTag::__document_metadata) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for document_metadata",
));
}
result.document_metadata = map.next_value::<std::option::Option<crate::model::answer_query_request::search_spec::search_result_list::search_result::chunk_info::DocumentMetadata>>()?
;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "conversational-search-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::answer_query_request::search_spec::search_result_list::search_result::chunk_info::DocumentMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__uri,
__title,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DocumentMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"uri" => Ok(__FieldTag::__uri),
"title" => Ok(__FieldTag::__title),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::answer_query_request::search_spec::search_result_list::search_result::chunk_info::DocumentMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DocumentMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
use std::option::Option::Some;
#[allow(unused_imports)]
use serde::de::Error;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__uri => {
if !fields.insert(__FieldTag::__uri) {
return std::result::Result::Err(A::Error::duplicate_field("multiple values for uri"));
}
result.uri = map.next_value::<std::option::Option<std::string::String>>()?.unwrap_or_default();
},
__FieldTag::__title => {
if !fields.insert(__FieldTag::__title) {
return std::result::Result::Err(A::Error::duplicate_field("multiple values for title"));
}
result.title = map.next_value::<std::option::Option<std::string::String>>()?.unwrap_or_default();
},
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
},
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "conversational-search-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::answer_query_request::QueryUnderstandingSpec {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__query_classification_spec,
__query_rephraser_spec,
__disable_spell_correction,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for QueryUnderstandingSpec")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"queryClassificationSpec" => {
Ok(__FieldTag::__query_classification_spec)
}
"query_classification_spec" => {
Ok(__FieldTag::__query_classification_spec)
}
"queryRephraserSpec" => Ok(__FieldTag::__query_rephraser_spec),
"query_rephraser_spec" => Ok(__FieldTag::__query_rephraser_spec),
"disableSpellCorrection" => Ok(__FieldTag::__disable_spell_correction),
"disable_spell_correction" => {
Ok(__FieldTag::__disable_spell_correction)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::answer_query_request::QueryUnderstandingSpec;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct QueryUnderstandingSpec")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__query_classification_spec => {
if !fields.insert(__FieldTag::__query_classification_spec) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for query_classification_spec",
));
}
result.query_classification_spec = map.next_value::<std::option::Option<crate::model::answer_query_request::query_understanding_spec::QueryClassificationSpec>>()?
;
}
__FieldTag::__query_rephraser_spec => {
if !fields.insert(__FieldTag::__query_rephraser_spec) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for query_rephraser_spec",
));
}
result.query_rephraser_spec = map.next_value::<std::option::Option<crate::model::answer_query_request::query_understanding_spec::QueryRephraserSpec>>()?
;
}
__FieldTag::__disable_spell_correction => {
if !fields.insert(__FieldTag::__disable_spell_correction) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for disable_spell_correction",
));
}
result.disable_spell_correction = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "conversational-search-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::answer_query_request::query_understanding_spec::QueryClassificationSpec
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__types,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for QueryClassificationSpec")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"types" => Ok(__FieldTag::__types),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value =
super::answer_query_request::query_understanding_spec::QueryClassificationSpec;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct QueryClassificationSpec")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__types => {
if !fields.insert(__FieldTag::__types) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for types",
));
}
result.types = map.next_value::<std::option::Option<std::vec::Vec<crate::model::answer_query_request::query_understanding_spec::query_classification_spec::Type>>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "conversational-search-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::answer_query_request::query_understanding_spec::QueryRephraserSpec
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__disable,
__max_rephrase_steps,
__model_spec,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for QueryRephraserSpec")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"disable" => Ok(__FieldTag::__disable),
"maxRephraseSteps" => Ok(__FieldTag::__max_rephrase_steps),
"max_rephrase_steps" => Ok(__FieldTag::__max_rephrase_steps),
"modelSpec" => Ok(__FieldTag::__model_spec),
"model_spec" => Ok(__FieldTag::__model_spec),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::answer_query_request::query_understanding_spec::QueryRephraserSpec;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct QueryRephraserSpec")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__disable => {
if !fields.insert(__FieldTag::__disable) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for disable",
));
}
result.disable = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__max_rephrase_steps => {
if !fields.insert(__FieldTag::__max_rephrase_steps) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for max_rephrase_steps",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.max_rephrase_steps =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__model_spec => {
if !fields.insert(__FieldTag::__model_spec) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for model_spec",
));
}
result.model_spec = map.next_value::<std::option::Option<crate::model::answer_query_request::query_understanding_spec::query_rephraser_spec::ModelSpec>>()?
;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "conversational-search-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::answer_query_request::query_understanding_spec::query_rephraser_spec::ModelSpec
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__model_type,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ModelSpec")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"modelType" => Ok(__FieldTag::__model_type),
"model_type" => Ok(__FieldTag::__model_type),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::answer_query_request::query_understanding_spec::query_rephraser_spec::ModelSpec;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ModelSpec")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__model_type => {
if !fields.insert(__FieldTag::__model_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for model_type",
));
}
result.model_type = map.next_value::<std::option::Option<crate::model::answer_query_request::query_understanding_spec::query_rephraser_spec::model_spec::ModelType>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "conversational-search-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::answer_query_request::EndUserSpec {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__end_user_metadata,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for EndUserSpec")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"endUserMetadata" => Ok(__FieldTag::__end_user_metadata),
"end_user_metadata" => Ok(__FieldTag::__end_user_metadata),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::answer_query_request::EndUserSpec;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct EndUserSpec")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__end_user_metadata => {
if !fields.insert(__FieldTag::__end_user_metadata) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for end_user_metadata",
));
}
result.end_user_metadata = map.next_value::<std::option::Option<std::vec::Vec<crate::model::answer_query_request::end_user_spec::EndUserMetaData>>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "conversational-search-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::answer_query_request::end_user_spec::EndUserMetaData
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__chunk_info,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for EndUserMetaData")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"chunkInfo" => Ok(__FieldTag::__chunk_info),
"chunk_info" => Ok(__FieldTag::__chunk_info),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::answer_query_request::end_user_spec::EndUserMetaData;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct EndUserMetaData")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__chunk_info => {
if !fields.insert(__FieldTag::__chunk_info) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for chunk_info",
));
}
if result.content.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `content`, a oneof with full ID .google.cloud.discoveryengine.v1.AnswerQueryRequest.EndUserSpec.EndUserMetaData.chunk_info, latest field was chunkInfo",
));
}
result.content = std::option::Option::Some(
crate::model::answer_query_request::end_user_spec::end_user_meta_data::Content::ChunkInfo(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::answer_query_request::end_user_spec::end_user_meta_data::ChunkInfo>>>()?.unwrap_or_default()
),
);
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "conversational-search-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::answer_query_request::end_user_spec::end_user_meta_data::ChunkInfo
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__content,
__document_metadata,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ChunkInfo")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"content" => Ok(__FieldTag::__content),
"documentMetadata" => Ok(__FieldTag::__document_metadata),
"document_metadata" => Ok(__FieldTag::__document_metadata),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::answer_query_request::end_user_spec::end_user_meta_data::ChunkInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ChunkInfo")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__content => {
if !fields.insert(__FieldTag::__content) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for content",
));
}
result.content = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__document_metadata => {
if !fields.insert(__FieldTag::__document_metadata) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for document_metadata",
));
}
result.document_metadata = map.next_value::<std::option::Option<crate::model::answer_query_request::end_user_spec::end_user_meta_data::chunk_info::DocumentMetadata>>()?
;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "conversational-search-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::answer_query_request::end_user_spec::end_user_meta_data::chunk_info::DocumentMetadata
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__title,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DocumentMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"title" => Ok(__FieldTag::__title),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::answer_query_request::end_user_spec::end_user_meta_data::chunk_info::DocumentMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DocumentMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__title => {
if !fields.insert(__FieldTag::__title) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for title",
));
}
result.title = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "conversational-search-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::AnswerQueryResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__answer,
__session,
__answer_query_token,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for AnswerQueryResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"answer" => Ok(__FieldTag::__answer),
"session" => Ok(__FieldTag::__session),
"answerQueryToken" => Ok(__FieldTag::__answer_query_token),
"answer_query_token" => Ok(__FieldTag::__answer_query_token),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::AnswerQueryResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct AnswerQueryResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__answer => {
if !fields.insert(__FieldTag::__answer) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for answer",
));
}
result.answer =
map.next_value::<std::option::Option<crate::model::Answer>>()?;
}
__FieldTag::__session => {
if !fields.insert(__FieldTag::__session) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for session",
));
}
result.session =
map.next_value::<std::option::Option<crate::model::Session>>()?;
}
__FieldTag::__answer_query_token => {
if !fields.insert(__FieldTag::__answer_query_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for answer_query_token",
));
}
result.answer_query_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "conversational-search-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::GetAnswerRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for GetAnswerRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::GetAnswerRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GetAnswerRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::CreateSessionRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__parent,
__session,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for CreateSessionRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"parent" => Ok(__FieldTag::__parent),
"session" => Ok(__FieldTag::__session),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CreateSessionRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CreateSessionRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__session => {
if !fields.insert(__FieldTag::__session) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for session",
));
}
result.session =
map.next_value::<std::option::Option<crate::model::Session>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::UpdateSessionRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__session,
__update_mask,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for UpdateSessionRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"session" => Ok(__FieldTag::__session),
"updateMask" => Ok(__FieldTag::__update_mask),
"update_mask" => Ok(__FieldTag::__update_mask),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::UpdateSessionRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct UpdateSessionRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__session => {
if !fields.insert(__FieldTag::__session) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for session",
));
}
result.session =
map.next_value::<std::option::Option<crate::model::Session>>()?;
}
__FieldTag::__update_mask => {
if !fields.insert(__FieldTag::__update_mask) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_mask",
));
}
result.update_mask =
map.next_value::<std::option::Option<wkt::FieldMask>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::DeleteSessionRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DeleteSessionRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DeleteSessionRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DeleteSessionRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::GetSessionRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
__include_answer_details,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for GetSessionRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
"includeAnswerDetails" => Ok(__FieldTag::__include_answer_details),
"include_answer_details" => Ok(__FieldTag::__include_answer_details),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::GetSessionRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GetSessionRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__include_answer_details => {
if !fields.insert(__FieldTag::__include_answer_details) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for include_answer_details",
));
}
result.include_answer_details = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ListSessionsRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__parent,
__page_size,
__page_token,
__filter,
__order_by,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ListSessionsRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"parent" => Ok(__FieldTag::__parent),
"pageSize" => Ok(__FieldTag::__page_size),
"page_size" => Ok(__FieldTag::__page_size),
"pageToken" => Ok(__FieldTag::__page_token),
"page_token" => Ok(__FieldTag::__page_token),
"filter" => Ok(__FieldTag::__filter),
"orderBy" => Ok(__FieldTag::__order_by),
"order_by" => Ok(__FieldTag::__order_by),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListSessionsRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListSessionsRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__page_size => {
if !fields.insert(__FieldTag::__page_size) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_size",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.page_size = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__page_token => {
if !fields.insert(__FieldTag::__page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_token",
));
}
result.page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__filter => {
if !fields.insert(__FieldTag::__filter) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for filter",
));
}
result.filter = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__order_by => {
if !fields.insert(__FieldTag::__order_by) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for order_by",
));
}
result.order_by = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ListSessionsResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__sessions,
__next_page_token,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ListSessionsResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"sessions" => Ok(__FieldTag::__sessions),
"nextPageToken" => Ok(__FieldTag::__next_page_token),
"next_page_token" => Ok(__FieldTag::__next_page_token),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListSessionsResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListSessionsResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__sessions => {
if !fields.insert(__FieldTag::__sessions) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for sessions",
));
}
result.sessions = map.next_value::<std::option::Option<std::vec::Vec<crate::model::Session>>>()?.unwrap_or_default();
}
__FieldTag::__next_page_token => {
if !fields.insert(__FieldTag::__next_page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for next_page_token",
));
}
result.next_page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "search-tuning-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::CustomTuningModel {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
__display_name,
__model_version,
__model_state,
__create_time,
__training_start_time,
__metrics,
__error_message,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for CustomTuningModel")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
"displayName" => Ok(__FieldTag::__display_name),
"display_name" => Ok(__FieldTag::__display_name),
"modelVersion" => Ok(__FieldTag::__model_version),
"model_version" => Ok(__FieldTag::__model_version),
"modelState" => Ok(__FieldTag::__model_state),
"model_state" => Ok(__FieldTag::__model_state),
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"trainingStartTime" => Ok(__FieldTag::__training_start_time),
"training_start_time" => Ok(__FieldTag::__training_start_time),
"metrics" => Ok(__FieldTag::__metrics),
"errorMessage" => Ok(__FieldTag::__error_message),
"error_message" => Ok(__FieldTag::__error_message),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CustomTuningModel;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CustomTuningModel")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__display_name => {
if !fields.insert(__FieldTag::__display_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for display_name",
));
}
result.display_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__model_version => {
if !fields.insert(__FieldTag::__model_version) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for model_version",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.model_version =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__model_state => {
if !fields.insert(__FieldTag::__model_state) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for model_state",
));
}
result.model_state =
map.next_value::<std::option::Option<
crate::model::custom_tuning_model::ModelState,
>>()?
.unwrap_or_default();
}
__FieldTag::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__training_start_time => {
if !fields.insert(__FieldTag::__training_start_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for training_start_time",
));
}
result.training_start_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__metrics => {
if !fields.insert(__FieldTag::__metrics) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for metrics",
));
}
struct __With(
std::option::Option<
std::collections::HashMap<std::string::String, f64>,
>,
);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::<
std::option::Option<
std::collections::HashMap<
serde_with::Same,
wkt::internal::F64,
>,
>,
>::deserialize(deserializer)
.map(__With)
}
}
result.metrics = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__error_message => {
if !fields.insert(__FieldTag::__error_message) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for error_message",
));
}
result.error_message = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "data-store-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::DataStore {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
__display_name,
__industry_vertical,
__solution_types,
__default_schema_id,
__content_config,
__create_time,
__advanced_site_search_config,
__natural_language_query_understanding_config,
__kms_key_name,
__cmek_config,
__billing_estimation,
__acl_enabled,
__workspace_config,
__document_processing_config,
__starting_schema,
__healthcare_fhir_config,
__identity_mapping_store,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DataStore")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
"displayName" => Ok(__FieldTag::__display_name),
"display_name" => Ok(__FieldTag::__display_name),
"industryVertical" => Ok(__FieldTag::__industry_vertical),
"industry_vertical" => Ok(__FieldTag::__industry_vertical),
"solutionTypes" => Ok(__FieldTag::__solution_types),
"solution_types" => Ok(__FieldTag::__solution_types),
"defaultSchemaId" => Ok(__FieldTag::__default_schema_id),
"default_schema_id" => Ok(__FieldTag::__default_schema_id),
"contentConfig" => Ok(__FieldTag::__content_config),
"content_config" => Ok(__FieldTag::__content_config),
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"advancedSiteSearchConfig" => {
Ok(__FieldTag::__advanced_site_search_config)
}
"advanced_site_search_config" => {
Ok(__FieldTag::__advanced_site_search_config)
}
"naturalLanguageQueryUnderstandingConfig" => {
Ok(__FieldTag::__natural_language_query_understanding_config)
}
"natural_language_query_understanding_config" => {
Ok(__FieldTag::__natural_language_query_understanding_config)
}
"kmsKeyName" => Ok(__FieldTag::__kms_key_name),
"kms_key_name" => Ok(__FieldTag::__kms_key_name),
"cmekConfig" => Ok(__FieldTag::__cmek_config),
"cmek_config" => Ok(__FieldTag::__cmek_config),
"billingEstimation" => Ok(__FieldTag::__billing_estimation),
"billing_estimation" => Ok(__FieldTag::__billing_estimation),
"aclEnabled" => Ok(__FieldTag::__acl_enabled),
"acl_enabled" => Ok(__FieldTag::__acl_enabled),
"workspaceConfig" => Ok(__FieldTag::__workspace_config),
"workspace_config" => Ok(__FieldTag::__workspace_config),
"documentProcessingConfig" => {
Ok(__FieldTag::__document_processing_config)
}
"document_processing_config" => {
Ok(__FieldTag::__document_processing_config)
}
"startingSchema" => Ok(__FieldTag::__starting_schema),
"starting_schema" => Ok(__FieldTag::__starting_schema),
"healthcareFhirConfig" => Ok(__FieldTag::__healthcare_fhir_config),
"healthcare_fhir_config" => Ok(__FieldTag::__healthcare_fhir_config),
"identityMappingStore" => Ok(__FieldTag::__identity_mapping_store),
"identity_mapping_store" => Ok(__FieldTag::__identity_mapping_store),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DataStore;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DataStore")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__display_name => {
if !fields.insert(__FieldTag::__display_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for display_name",
));
}
result.display_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__industry_vertical => {
if !fields.insert(__FieldTag::__industry_vertical) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for industry_vertical",
));
}
result.industry_vertical = map
.next_value::<std::option::Option<crate::model::IndustryVertical>>(
)?
.unwrap_or_default();
}
__FieldTag::__solution_types => {
if !fields.insert(__FieldTag::__solution_types) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for solution_types",
));
}
result.solution_types = map.next_value::<std::option::Option<std::vec::Vec<crate::model::SolutionType>>>()?.unwrap_or_default();
}
__FieldTag::__default_schema_id => {
if !fields.insert(__FieldTag::__default_schema_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for default_schema_id",
));
}
result.default_schema_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__content_config => {
if !fields.insert(__FieldTag::__content_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for content_config",
));
}
result.content_config = map.next_value::<std::option::Option<crate::model::data_store::ContentConfig>>()?.unwrap_or_default();
}
__FieldTag::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__advanced_site_search_config => {
if !fields.insert(__FieldTag::__advanced_site_search_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for advanced_site_search_config",
));
}
result.advanced_site_search_config = map.next_value::<std::option::Option<crate::model::AdvancedSiteSearchConfig>>()?
;
}
__FieldTag::__natural_language_query_understanding_config => {
if !fields
.insert(__FieldTag::__natural_language_query_understanding_config)
{
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for natural_language_query_understanding_config",
));
}
result.natural_language_query_understanding_config =
map.next_value::<std::option::Option<
crate::model::NaturalLanguageQueryUnderstandingConfig,
>>()?;
}
__FieldTag::__kms_key_name => {
if !fields.insert(__FieldTag::__kms_key_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for kms_key_name",
));
}
result.kms_key_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__cmek_config => {
if !fields.insert(__FieldTag::__cmek_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cmek_config",
));
}
result.cmek_config =
map.next_value::<std::option::Option<crate::model::CmekConfig>>()?;
}
__FieldTag::__billing_estimation => {
if !fields.insert(__FieldTag::__billing_estimation) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for billing_estimation",
));
}
result.billing_estimation =
map.next_value::<std::option::Option<
crate::model::data_store::BillingEstimation,
>>()?;
}
__FieldTag::__acl_enabled => {
if !fields.insert(__FieldTag::__acl_enabled) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for acl_enabled",
));
}
result.acl_enabled = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__workspace_config => {
if !fields.insert(__FieldTag::__workspace_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for workspace_config",
));
}
result.workspace_config = map
.next_value::<std::option::Option<crate::model::WorkspaceConfig>>(
)?;
}
__FieldTag::__document_processing_config => {
if !fields.insert(__FieldTag::__document_processing_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for document_processing_config",
));
}
result.document_processing_config = map.next_value::<std::option::Option<crate::model::DocumentProcessingConfig>>()?
;
}
__FieldTag::__starting_schema => {
if !fields.insert(__FieldTag::__starting_schema) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for starting_schema",
));
}
result.starting_schema =
map.next_value::<std::option::Option<crate::model::Schema>>()?;
}
__FieldTag::__healthcare_fhir_config => {
if !fields.insert(__FieldTag::__healthcare_fhir_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for healthcare_fhir_config",
));
}
result.healthcare_fhir_config = map.next_value::<std::option::Option<crate::model::HealthcareFhirConfig>>()?
;
}
__FieldTag::__identity_mapping_store => {
if !fields.insert(__FieldTag::__identity_mapping_store) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for identity_mapping_store",
));
}
result.identity_mapping_store = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "data-store-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::data_store::BillingEstimation {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__structured_data_size,
__unstructured_data_size,
__website_data_size,
__structured_data_update_time,
__unstructured_data_update_time,
__website_data_update_time,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for BillingEstimation")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"structuredDataSize" => Ok(__FieldTag::__structured_data_size),
"structured_data_size" => Ok(__FieldTag::__structured_data_size),
"unstructuredDataSize" => Ok(__FieldTag::__unstructured_data_size),
"unstructured_data_size" => Ok(__FieldTag::__unstructured_data_size),
"websiteDataSize" => Ok(__FieldTag::__website_data_size),
"website_data_size" => Ok(__FieldTag::__website_data_size),
"structuredDataUpdateTime" => {
Ok(__FieldTag::__structured_data_update_time)
}
"structured_data_update_time" => {
Ok(__FieldTag::__structured_data_update_time)
}
"unstructuredDataUpdateTime" => {
Ok(__FieldTag::__unstructured_data_update_time)
}
"unstructured_data_update_time" => {
Ok(__FieldTag::__unstructured_data_update_time)
}
"websiteDataUpdateTime" => Ok(__FieldTag::__website_data_update_time),
"website_data_update_time" => {
Ok(__FieldTag::__website_data_update_time)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::data_store::BillingEstimation;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BillingEstimation")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__structured_data_size => {
if !fields.insert(__FieldTag::__structured_data_size) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for structured_data_size",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.structured_data_size =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__unstructured_data_size => {
if !fields.insert(__FieldTag::__unstructured_data_size) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for unstructured_data_size",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.unstructured_data_size =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__website_data_size => {
if !fields.insert(__FieldTag::__website_data_size) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for website_data_size",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.website_data_size =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__structured_data_update_time => {
if !fields.insert(__FieldTag::__structured_data_update_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for structured_data_update_time",
));
}
result.structured_data_update_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__unstructured_data_update_time => {
if !fields.insert(__FieldTag::__unstructured_data_update_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for unstructured_data_update_time",
));
}
result.unstructured_data_update_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__website_data_update_time => {
if !fields.insert(__FieldTag::__website_data_update_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for website_data_update_time",
));
}
result.website_data_update_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "data-store-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::AdvancedSiteSearchConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__disable_initial_index,
__disable_automatic_refresh,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for AdvancedSiteSearchConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"disableInitialIndex" => Ok(__FieldTag::__disable_initial_index),
"disable_initial_index" => Ok(__FieldTag::__disable_initial_index),
"disableAutomaticRefresh" => {
Ok(__FieldTag::__disable_automatic_refresh)
}
"disable_automatic_refresh" => {
Ok(__FieldTag::__disable_automatic_refresh)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::AdvancedSiteSearchConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct AdvancedSiteSearchConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__disable_initial_index => {
if !fields.insert(__FieldTag::__disable_initial_index) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for disable_initial_index",
));
}
result.disable_initial_index =
map.next_value::<std::option::Option<bool>>()?;
}
__FieldTag::__disable_automatic_refresh => {
if !fields.insert(__FieldTag::__disable_automatic_refresh) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for disable_automatic_refresh",
));
}
result.disable_automatic_refresh =
map.next_value::<std::option::Option<bool>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "data-store-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::NaturalLanguageQueryUnderstandingConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__mode,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter
.write_str("a field name for NaturalLanguageQueryUnderstandingConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"mode" => Ok(__FieldTag::__mode),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::NaturalLanguageQueryUnderstandingConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct NaturalLanguageQueryUnderstandingConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__mode => {
if !fields.insert(__FieldTag::__mode) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for mode",
));
}
result.mode = map
.next_value::<std::option::Option<
crate::model::natural_language_query_understanding_config::Mode,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "data-store-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::WorkspaceConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__type,
__dasher_customer_id,
__super_admin_service_account,
__super_admin_email_address,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for WorkspaceConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"type" => Ok(__FieldTag::__type),
"dasherCustomerId" => Ok(__FieldTag::__dasher_customer_id),
"dasher_customer_id" => Ok(__FieldTag::__dasher_customer_id),
"superAdminServiceAccount" => {
Ok(__FieldTag::__super_admin_service_account)
}
"super_admin_service_account" => {
Ok(__FieldTag::__super_admin_service_account)
}
"superAdminEmailAddress" => Ok(__FieldTag::__super_admin_email_address),
"super_admin_email_address" => {
Ok(__FieldTag::__super_admin_email_address)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::WorkspaceConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct WorkspaceConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__type => {
if !fields.insert(__FieldTag::__type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for type",
));
}
result.r#type = map.next_value::<std::option::Option<crate::model::workspace_config::Type>>()?.unwrap_or_default();
}
__FieldTag::__dasher_customer_id => {
if !fields.insert(__FieldTag::__dasher_customer_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for dasher_customer_id",
));
}
result.dasher_customer_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__super_admin_service_account => {
if !fields.insert(__FieldTag::__super_admin_service_account) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for super_admin_service_account",
));
}
result.super_admin_service_account = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__super_admin_email_address => {
if !fields.insert(__FieldTag::__super_admin_email_address) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for super_admin_email_address",
));
}
result.super_admin_email_address = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "data-store-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::CreateDataStoreRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__cmek_config_name,
__disable_cmek,
__parent,
__data_store,
__data_store_id,
__create_advanced_site_search,
__skip_default_schema_creation,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for CreateDataStoreRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"cmekConfigName" => Ok(__FieldTag::__cmek_config_name),
"cmek_config_name" => Ok(__FieldTag::__cmek_config_name),
"disableCmek" => Ok(__FieldTag::__disable_cmek),
"disable_cmek" => Ok(__FieldTag::__disable_cmek),
"parent" => Ok(__FieldTag::__parent),
"dataStore" => Ok(__FieldTag::__data_store),
"data_store" => Ok(__FieldTag::__data_store),
"dataStoreId" => Ok(__FieldTag::__data_store_id),
"data_store_id" => Ok(__FieldTag::__data_store_id),
"createAdvancedSiteSearch" => {
Ok(__FieldTag::__create_advanced_site_search)
}
"create_advanced_site_search" => {
Ok(__FieldTag::__create_advanced_site_search)
}
"skipDefaultSchemaCreation" => {
Ok(__FieldTag::__skip_default_schema_creation)
}
"skip_default_schema_creation" => {
Ok(__FieldTag::__skip_default_schema_creation)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CreateDataStoreRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CreateDataStoreRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__cmek_config_name => {
if !fields.insert(__FieldTag::__cmek_config_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cmek_config_name",
));
}
if result.cmek_options.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `cmek_options`, a oneof with full ID .google.cloud.discoveryengine.v1.CreateDataStoreRequest.cmek_config_name, latest field was cmekConfigName",
));
}
result.cmek_options = std::option::Option::Some(
crate::model::create_data_store_request::CmekOptions::CmekConfigName(
map.next_value::<std::option::Option<std::string::String>>()?.unwrap_or_default()
),
);
}
__FieldTag::__disable_cmek => {
if !fields.insert(__FieldTag::__disable_cmek) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for disable_cmek",
));
}
if result.cmek_options.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `cmek_options`, a oneof with full ID .google.cloud.discoveryengine.v1.CreateDataStoreRequest.disable_cmek, latest field was disableCmek",
));
}
result.cmek_options = std::option::Option::Some(
crate::model::create_data_store_request::CmekOptions::DisableCmek(
map.next_value::<std::option::Option<bool>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__data_store => {
if !fields.insert(__FieldTag::__data_store) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for data_store",
));
}
result.data_store =
map.next_value::<std::option::Option<crate::model::DataStore>>()?;
}
__FieldTag::__data_store_id => {
if !fields.insert(__FieldTag::__data_store_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for data_store_id",
));
}
result.data_store_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__create_advanced_site_search => {
if !fields.insert(__FieldTag::__create_advanced_site_search) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_advanced_site_search",
));
}
result.create_advanced_site_search = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__skip_default_schema_creation => {
if !fields.insert(__FieldTag::__skip_default_schema_creation) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for skip_default_schema_creation",
));
}
result.skip_default_schema_creation = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "data-store-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::GetDataStoreRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for GetDataStoreRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::GetDataStoreRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GetDataStoreRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "data-store-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::CreateDataStoreMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__create_time,
__update_time,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for CreateDataStoreMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"updateTime" => Ok(__FieldTag::__update_time),
"update_time" => Ok(__FieldTag::__update_time),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CreateDataStoreMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CreateDataStoreMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__update_time => {
if !fields.insert(__FieldTag::__update_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_time",
));
}
result.update_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "data-store-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ListDataStoresRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__parent,
__page_size,
__page_token,
__filter,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ListDataStoresRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"parent" => Ok(__FieldTag::__parent),
"pageSize" => Ok(__FieldTag::__page_size),
"page_size" => Ok(__FieldTag::__page_size),
"pageToken" => Ok(__FieldTag::__page_token),
"page_token" => Ok(__FieldTag::__page_token),
"filter" => Ok(__FieldTag::__filter),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListDataStoresRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListDataStoresRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__page_size => {
if !fields.insert(__FieldTag::__page_size) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_size",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.page_size = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__page_token => {
if !fields.insert(__FieldTag::__page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_token",
));
}
result.page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__filter => {
if !fields.insert(__FieldTag::__filter) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for filter",
));
}
result.filter = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "data-store-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ListDataStoresResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__data_stores,
__next_page_token,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ListDataStoresResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"dataStores" => Ok(__FieldTag::__data_stores),
"data_stores" => Ok(__FieldTag::__data_stores),
"nextPageToken" => Ok(__FieldTag::__next_page_token),
"next_page_token" => Ok(__FieldTag::__next_page_token),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListDataStoresResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListDataStoresResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__data_stores => {
if !fields.insert(__FieldTag::__data_stores) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for data_stores",
));
}
result.data_stores = map.next_value::<std::option::Option<std::vec::Vec<crate::model::DataStore>>>()?.unwrap_or_default();
}
__FieldTag::__next_page_token => {
if !fields.insert(__FieldTag::__next_page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for next_page_token",
));
}
result.next_page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "data-store-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::DeleteDataStoreRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DeleteDataStoreRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DeleteDataStoreRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DeleteDataStoreRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "data-store-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::UpdateDataStoreRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__data_store,
__update_mask,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for UpdateDataStoreRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"dataStore" => Ok(__FieldTag::__data_store),
"data_store" => Ok(__FieldTag::__data_store),
"updateMask" => Ok(__FieldTag::__update_mask),
"update_mask" => Ok(__FieldTag::__update_mask),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::UpdateDataStoreRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct UpdateDataStoreRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__data_store => {
if !fields.insert(__FieldTag::__data_store) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for data_store",
));
}
result.data_store =
map.next_value::<std::option::Option<crate::model::DataStore>>()?;
}
__FieldTag::__update_mask => {
if !fields.insert(__FieldTag::__update_mask) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_mask",
));
}
result.update_mask =
map.next_value::<std::option::Option<wkt::FieldMask>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "data-store-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::DeleteDataStoreMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__create_time,
__update_time,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DeleteDataStoreMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"updateTime" => Ok(__FieldTag::__update_time),
"update_time" => Ok(__FieldTag::__update_time),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DeleteDataStoreMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DeleteDataStoreMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__update_time => {
if !fields.insert(__FieldTag::__update_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_time",
));
}
result.update_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "conversational-search-service",
feature = "document-service",
feature = "recommendation-service",
feature = "search-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::Document {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__struct_data,
__json_data,
__name,
__id,
__schema_id,
__content,
__parent_document_id,
__derived_struct_data,
__acl_info,
__index_time,
__index_status,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Document")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"structData" => Ok(__FieldTag::__struct_data),
"struct_data" => Ok(__FieldTag::__struct_data),
"jsonData" => Ok(__FieldTag::__json_data),
"json_data" => Ok(__FieldTag::__json_data),
"name" => Ok(__FieldTag::__name),
"id" => Ok(__FieldTag::__id),
"schemaId" => Ok(__FieldTag::__schema_id),
"schema_id" => Ok(__FieldTag::__schema_id),
"content" => Ok(__FieldTag::__content),
"parentDocumentId" => Ok(__FieldTag::__parent_document_id),
"parent_document_id" => Ok(__FieldTag::__parent_document_id),
"derivedStructData" => Ok(__FieldTag::__derived_struct_data),
"derived_struct_data" => Ok(__FieldTag::__derived_struct_data),
"aclInfo" => Ok(__FieldTag::__acl_info),
"acl_info" => Ok(__FieldTag::__acl_info),
"indexTime" => Ok(__FieldTag::__index_time),
"index_time" => Ok(__FieldTag::__index_time),
"indexStatus" => Ok(__FieldTag::__index_status),
"index_status" => Ok(__FieldTag::__index_status),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Document;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Document")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__struct_data => {
if !fields.insert(__FieldTag::__struct_data) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for struct_data",
));
}
if result.data.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `data`, a oneof with full ID .google.cloud.discoveryengine.v1.Document.struct_data, latest field was structData",
));
}
result.data = std::option::Option::Some(
crate::model::document::Data::StructData(
map.next_value::<std::option::Option<std::boxed::Box<wkt::Struct>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__json_data => {
if !fields.insert(__FieldTag::__json_data) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for json_data",
));
}
if result.data.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `data`, a oneof with full ID .google.cloud.discoveryengine.v1.Document.json_data, latest field was jsonData",
));
}
result.data =
std::option::Option::Some(crate::model::document::Data::JsonData(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
));
}
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__id => {
if !fields.insert(__FieldTag::__id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for id",
));
}
result.id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__schema_id => {
if !fields.insert(__FieldTag::__schema_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for schema_id",
));
}
result.schema_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__content => {
if !fields.insert(__FieldTag::__content) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for content",
));
}
result.content = map
.next_value::<std::option::Option<crate::model::document::Content>>(
)?;
}
__FieldTag::__parent_document_id => {
if !fields.insert(__FieldTag::__parent_document_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent_document_id",
));
}
result.parent_document_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__derived_struct_data => {
if !fields.insert(__FieldTag::__derived_struct_data) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for derived_struct_data",
));
}
result.derived_struct_data =
map.next_value::<std::option::Option<wkt::Struct>>()?;
}
__FieldTag::__acl_info => {
if !fields.insert(__FieldTag::__acl_info) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for acl_info",
));
}
result.acl_info = map
.next_value::<std::option::Option<crate::model::document::AclInfo>>(
)?;
}
__FieldTag::__index_time => {
if !fields.insert(__FieldTag::__index_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for index_time",
));
}
result.index_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__index_status => {
if !fields.insert(__FieldTag::__index_status) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for index_status",
));
}
result.index_status = map.next_value::<std::option::Option<crate::model::document::IndexStatus>>()?
;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "conversational-search-service",
feature = "document-service",
feature = "recommendation-service",
feature = "search-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::document::Content {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__raw_bytes,
__uri,
__mime_type,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Content")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"rawBytes" => Ok(__FieldTag::__raw_bytes),
"raw_bytes" => Ok(__FieldTag::__raw_bytes),
"uri" => Ok(__FieldTag::__uri),
"mimeType" => Ok(__FieldTag::__mime_type),
"mime_type" => Ok(__FieldTag::__mime_type),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::document::Content;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Content")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__raw_bytes => {
if !fields.insert(__FieldTag::__raw_bytes) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for raw_bytes",
));
}
struct __With(std::option::Option<::bytes::Bytes>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<serde_with::base64::Base64> >::deserialize(deserializer).map(__With)
}
}
if result.content.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `content`, a oneof with full ID .google.cloud.discoveryengine.v1.Document.Content.raw_bytes, latest field was rawBytes",
));
}
result.content = std::option::Option::Some(
crate::model::document::content::Content::RawBytes(
map.next_value::<__With>()?.0.unwrap_or_default(),
),
);
}
__FieldTag::__uri => {
if !fields.insert(__FieldTag::__uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for uri",
));
}
if result.content.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `content`, a oneof with full ID .google.cloud.discoveryengine.v1.Document.Content.uri, latest field was uri",
));
}
result.content = std::option::Option::Some(
crate::model::document::content::Content::Uri(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__mime_type => {
if !fields.insert(__FieldTag::__mime_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for mime_type",
));
}
result.mime_type = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "conversational-search-service",
feature = "document-service",
feature = "recommendation-service",
feature = "search-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::document::AclInfo {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__readers,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for AclInfo")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"readers" => Ok(__FieldTag::__readers),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::document::AclInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct AclInfo")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__readers => {
if !fields.insert(__FieldTag::__readers) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for readers",
));
}
result.readers = map
.next_value::<std::option::Option<
std::vec::Vec<
crate::model::document::acl_info::AccessRestriction,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "conversational-search-service",
feature = "document-service",
feature = "recommendation-service",
feature = "search-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::document::acl_info::AccessRestriction {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__principals,
__idp_wide,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for AccessRestriction")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"principals" => Ok(__FieldTag::__principals),
"idpWide" => Ok(__FieldTag::__idp_wide),
"idp_wide" => Ok(__FieldTag::__idp_wide),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::document::acl_info::AccessRestriction;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct AccessRestriction")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__principals => {
if !fields.insert(__FieldTag::__principals) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for principals",
));
}
result.principals = map.next_value::<std::option::Option<std::vec::Vec<crate::model::Principal>>>()?.unwrap_or_default();
}
__FieldTag::__idp_wide => {
if !fields.insert(__FieldTag::__idp_wide) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for idp_wide",
));
}
result.idp_wide = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "conversational-search-service",
feature = "document-service",
feature = "recommendation-service",
feature = "search-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::document::IndexStatus {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__index_time,
__error_samples,
__pending_message,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for IndexStatus")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"indexTime" => Ok(__FieldTag::__index_time),
"index_time" => Ok(__FieldTag::__index_time),
"errorSamples" => Ok(__FieldTag::__error_samples),
"error_samples" => Ok(__FieldTag::__error_samples),
"pendingMessage" => Ok(__FieldTag::__pending_message),
"pending_message" => Ok(__FieldTag::__pending_message),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::document::IndexStatus;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct IndexStatus")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__index_time => {
if !fields.insert(__FieldTag::__index_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for index_time",
));
}
result.index_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__error_samples => {
if !fields.insert(__FieldTag::__error_samples) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for error_samples",
));
}
result.error_samples =
map.next_value::<std::option::Option<
std::vec::Vec<google_cloud_rpc::model::Status>,
>>()?
.unwrap_or_default();
}
__FieldTag::__pending_message => {
if !fields.insert(__FieldTag::__pending_message) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for pending_message",
));
}
result.pending_message = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "data-store-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::DocumentProcessingConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
__chunking_config,
__default_parsing_config,
__parsing_config_overrides,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DocumentProcessingConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
"chunkingConfig" => Ok(__FieldTag::__chunking_config),
"chunking_config" => Ok(__FieldTag::__chunking_config),
"defaultParsingConfig" => Ok(__FieldTag::__default_parsing_config),
"default_parsing_config" => Ok(__FieldTag::__default_parsing_config),
"parsingConfigOverrides" => Ok(__FieldTag::__parsing_config_overrides),
"parsing_config_overrides" => {
Ok(__FieldTag::__parsing_config_overrides)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DocumentProcessingConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DocumentProcessingConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__chunking_config => {
if !fields.insert(__FieldTag::__chunking_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for chunking_config",
));
}
result.chunking_config = map.next_value::<std::option::Option<
crate::model::document_processing_config::ChunkingConfig,
>>()?;
}
__FieldTag::__default_parsing_config => {
if !fields.insert(__FieldTag::__default_parsing_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for default_parsing_config",
));
}
result.default_parsing_config = map.next_value::<std::option::Option<
crate::model::document_processing_config::ParsingConfig,
>>()?;
}
__FieldTag::__parsing_config_overrides => {
if !fields.insert(__FieldTag::__parsing_config_overrides) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parsing_config_overrides",
));
}
result.parsing_config_overrides = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
crate::model::document_processing_config::ParsingConfig,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "data-store-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::document_processing_config::ChunkingConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__layout_based_chunking_config,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ChunkingConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"layoutBasedChunkingConfig" => {
Ok(__FieldTag::__layout_based_chunking_config)
}
"layout_based_chunking_config" => {
Ok(__FieldTag::__layout_based_chunking_config)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::document_processing_config::ChunkingConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ChunkingConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__layout_based_chunking_config => {
if !fields.insert(__FieldTag::__layout_based_chunking_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for layout_based_chunking_config",
));
}
if result.chunk_mode.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `chunk_mode`, a oneof with full ID .google.cloud.discoveryengine.v1.DocumentProcessingConfig.ChunkingConfig.layout_based_chunking_config, latest field was layoutBasedChunkingConfig",
));
}
result.chunk_mode = std::option::Option::Some(
crate::model::document_processing_config::chunking_config::ChunkMode::LayoutBasedChunkingConfig(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::document_processing_config::chunking_config::LayoutBasedChunkingConfig>>>()?.unwrap_or_default()
),
);
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "data-store-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::document_processing_config::chunking_config::LayoutBasedChunkingConfig
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__chunk_size,
__include_ancestor_headings,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for LayoutBasedChunkingConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"chunkSize" => Ok(__FieldTag::__chunk_size),
"chunk_size" => Ok(__FieldTag::__chunk_size),
"includeAncestorHeadings" => {
Ok(__FieldTag::__include_ancestor_headings)
}
"include_ancestor_headings" => {
Ok(__FieldTag::__include_ancestor_headings)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value =
super::document_processing_config::chunking_config::LayoutBasedChunkingConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct LayoutBasedChunkingConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__chunk_size => {
if !fields.insert(__FieldTag::__chunk_size) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for chunk_size",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.chunk_size = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__include_ancestor_headings => {
if !fields.insert(__FieldTag::__include_ancestor_headings) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for include_ancestor_headings",
));
}
result.include_ancestor_headings = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "data-store-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::document_processing_config::ParsingConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__digital_parsing_config,
__ocr_parsing_config,
__layout_parsing_config,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ParsingConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"digitalParsingConfig" => Ok(__FieldTag::__digital_parsing_config),
"digital_parsing_config" => Ok(__FieldTag::__digital_parsing_config),
"ocrParsingConfig" => Ok(__FieldTag::__ocr_parsing_config),
"ocr_parsing_config" => Ok(__FieldTag::__ocr_parsing_config),
"layoutParsingConfig" => Ok(__FieldTag::__layout_parsing_config),
"layout_parsing_config" => Ok(__FieldTag::__layout_parsing_config),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::document_processing_config::ParsingConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ParsingConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__digital_parsing_config => {
if !fields.insert(__FieldTag::__digital_parsing_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for digital_parsing_config",
));
}
if result.type_dedicated_config.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `type_dedicated_config`, a oneof with full ID .google.cloud.discoveryengine.v1.DocumentProcessingConfig.ParsingConfig.digital_parsing_config, latest field was digitalParsingConfig",
));
}
result.type_dedicated_config = std::option::Option::Some(
crate::model::document_processing_config::parsing_config::TypeDedicatedConfig::DigitalParsingConfig(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::document_processing_config::parsing_config::DigitalParsingConfig>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__ocr_parsing_config => {
if !fields.insert(__FieldTag::__ocr_parsing_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for ocr_parsing_config",
));
}
if result.type_dedicated_config.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `type_dedicated_config`, a oneof with full ID .google.cloud.discoveryengine.v1.DocumentProcessingConfig.ParsingConfig.ocr_parsing_config, latest field was ocrParsingConfig",
));
}
result.type_dedicated_config = std::option::Option::Some(
crate::model::document_processing_config::parsing_config::TypeDedicatedConfig::OcrParsingConfig(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::document_processing_config::parsing_config::OcrParsingConfig>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__layout_parsing_config => {
if !fields.insert(__FieldTag::__layout_parsing_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for layout_parsing_config",
));
}
if result.type_dedicated_config.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `type_dedicated_config`, a oneof with full ID .google.cloud.discoveryengine.v1.DocumentProcessingConfig.ParsingConfig.layout_parsing_config, latest field was layoutParsingConfig",
));
}
result.type_dedicated_config = std::option::Option::Some(
crate::model::document_processing_config::parsing_config::TypeDedicatedConfig::LayoutParsingConfig(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::document_processing_config::parsing_config::LayoutParsingConfig>>>()?.unwrap_or_default()
),
);
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "data-store-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::document_processing_config::parsing_config::DigitalParsingConfig
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DigitalParsingConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
Ok(__FieldTag::Unknown(value.to_string()))
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::document_processing_config::parsing_config::DigitalParsingConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DigitalParsingConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "data-store-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::document_processing_config::parsing_config::OcrParsingConfig
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__enhanced_document_elements,
__use_native_text,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for OcrParsingConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"enhancedDocumentElements" => {
Ok(__FieldTag::__enhanced_document_elements)
}
"enhanced_document_elements" => {
Ok(__FieldTag::__enhanced_document_elements)
}
"useNativeText" => Ok(__FieldTag::__use_native_text),
"use_native_text" => Ok(__FieldTag::__use_native_text),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::document_processing_config::parsing_config::OcrParsingConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct OcrParsingConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__enhanced_document_elements => {
if !fields.insert(__FieldTag::__enhanced_document_elements) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for enhanced_document_elements",
));
}
result.enhanced_document_elements = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__use_native_text => {
if !fields.insert(__FieldTag::__use_native_text) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for use_native_text",
));
}
result.use_native_text = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "data-store-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::document_processing_config::parsing_config::LayoutParsingConfig
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__enable_table_annotation,
__enable_image_annotation,
__structured_content_types,
__exclude_html_elements,
__exclude_html_classes,
__exclude_html_ids,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for LayoutParsingConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"enableTableAnnotation" => Ok(__FieldTag::__enable_table_annotation),
"enable_table_annotation" => Ok(__FieldTag::__enable_table_annotation),
"enableImageAnnotation" => Ok(__FieldTag::__enable_image_annotation),
"enable_image_annotation" => Ok(__FieldTag::__enable_image_annotation),
"structuredContentTypes" => Ok(__FieldTag::__structured_content_types),
"structured_content_types" => {
Ok(__FieldTag::__structured_content_types)
}
"excludeHtmlElements" => Ok(__FieldTag::__exclude_html_elements),
"exclude_html_elements" => Ok(__FieldTag::__exclude_html_elements),
"excludeHtmlClasses" => Ok(__FieldTag::__exclude_html_classes),
"exclude_html_classes" => Ok(__FieldTag::__exclude_html_classes),
"excludeHtmlIds" => Ok(__FieldTag::__exclude_html_ids),
"exclude_html_ids" => Ok(__FieldTag::__exclude_html_ids),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::document_processing_config::parsing_config::LayoutParsingConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct LayoutParsingConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__enable_table_annotation => {
if !fields.insert(__FieldTag::__enable_table_annotation) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for enable_table_annotation",
));
}
result.enable_table_annotation = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__enable_image_annotation => {
if !fields.insert(__FieldTag::__enable_image_annotation) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for enable_image_annotation",
));
}
result.enable_image_annotation = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__structured_content_types => {
if !fields.insert(__FieldTag::__structured_content_types) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for structured_content_types",
));
}
result.structured_content_types = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__exclude_html_elements => {
if !fields.insert(__FieldTag::__exclude_html_elements) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for exclude_html_elements",
));
}
result.exclude_html_elements = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__exclude_html_classes => {
if !fields.insert(__FieldTag::__exclude_html_classes) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for exclude_html_classes",
));
}
result.exclude_html_classes = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__exclude_html_ids => {
if !fields.insert(__FieldTag::__exclude_html_ids) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for exclude_html_ids",
));
}
result.exclude_html_ids = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "document-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::GetDocumentRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for GetDocumentRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::GetDocumentRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GetDocumentRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "document-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ListDocumentsRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__parent,
__page_size,
__page_token,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ListDocumentsRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"parent" => Ok(__FieldTag::__parent),
"pageSize" => Ok(__FieldTag::__page_size),
"page_size" => Ok(__FieldTag::__page_size),
"pageToken" => Ok(__FieldTag::__page_token),
"page_token" => Ok(__FieldTag::__page_token),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListDocumentsRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListDocumentsRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__page_size => {
if !fields.insert(__FieldTag::__page_size) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_size",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.page_size = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__page_token => {
if !fields.insert(__FieldTag::__page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_token",
));
}
result.page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "document-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ListDocumentsResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__documents,
__next_page_token,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ListDocumentsResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"documents" => Ok(__FieldTag::__documents),
"nextPageToken" => Ok(__FieldTag::__next_page_token),
"next_page_token" => Ok(__FieldTag::__next_page_token),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListDocumentsResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListDocumentsResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__documents => {
if !fields.insert(__FieldTag::__documents) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for documents",
));
}
result.documents = map.next_value::<std::option::Option<std::vec::Vec<crate::model::Document>>>()?.unwrap_or_default();
}
__FieldTag::__next_page_token => {
if !fields.insert(__FieldTag::__next_page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for next_page_token",
));
}
result.next_page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "document-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::CreateDocumentRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__parent,
__document,
__document_id,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for CreateDocumentRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"parent" => Ok(__FieldTag::__parent),
"document" => Ok(__FieldTag::__document),
"documentId" => Ok(__FieldTag::__document_id),
"document_id" => Ok(__FieldTag::__document_id),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CreateDocumentRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CreateDocumentRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__document => {
if !fields.insert(__FieldTag::__document) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for document",
));
}
result.document =
map.next_value::<std::option::Option<crate::model::Document>>()?;
}
__FieldTag::__document_id => {
if !fields.insert(__FieldTag::__document_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for document_id",
));
}
result.document_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "document-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::UpdateDocumentRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__document,
__allow_missing,
__update_mask,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for UpdateDocumentRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"document" => Ok(__FieldTag::__document),
"allowMissing" => Ok(__FieldTag::__allow_missing),
"allow_missing" => Ok(__FieldTag::__allow_missing),
"updateMask" => Ok(__FieldTag::__update_mask),
"update_mask" => Ok(__FieldTag::__update_mask),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::UpdateDocumentRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct UpdateDocumentRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__document => {
if !fields.insert(__FieldTag::__document) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for document",
));
}
result.document =
map.next_value::<std::option::Option<crate::model::Document>>()?;
}
__FieldTag::__allow_missing => {
if !fields.insert(__FieldTag::__allow_missing) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for allow_missing",
));
}
result.allow_missing = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__update_mask => {
if !fields.insert(__FieldTag::__update_mask) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_mask",
));
}
result.update_mask =
map.next_value::<std::option::Option<wkt::FieldMask>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "document-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::DeleteDocumentRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DeleteDocumentRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DeleteDocumentRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DeleteDocumentRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "document-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::BatchGetDocumentsMetadataRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__parent,
__matcher,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for BatchGetDocumentsMetadataRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"parent" => Ok(__FieldTag::__parent),
"matcher" => Ok(__FieldTag::__matcher),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::BatchGetDocumentsMetadataRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BatchGetDocumentsMetadataRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__matcher => {
if !fields.insert(__FieldTag::__matcher) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for matcher",
));
}
result.matcher = map.next_value::<std::option::Option<
crate::model::batch_get_documents_metadata_request::Matcher,
>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "document-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::batch_get_documents_metadata_request::UrisMatcher {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__uris,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for UrisMatcher")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"uris" => Ok(__FieldTag::__uris),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::batch_get_documents_metadata_request::UrisMatcher;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct UrisMatcher")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__uris => {
if !fields.insert(__FieldTag::__uris) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for uris",
));
}
result.uris = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "document-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::batch_get_documents_metadata_request::FhirMatcher {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__fhir_resources,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for FhirMatcher")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"fhirResources" => Ok(__FieldTag::__fhir_resources),
"fhir_resources" => Ok(__FieldTag::__fhir_resources),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::batch_get_documents_metadata_request::FhirMatcher;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct FhirMatcher")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__fhir_resources => {
if !fields.insert(__FieldTag::__fhir_resources) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for fhir_resources",
));
}
result.fhir_resources = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "document-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::batch_get_documents_metadata_request::Matcher {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__uris_matcher,
__fhir_matcher,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Matcher")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"urisMatcher" => Ok(__FieldTag::__uris_matcher),
"uris_matcher" => Ok(__FieldTag::__uris_matcher),
"fhirMatcher" => Ok(__FieldTag::__fhir_matcher),
"fhir_matcher" => Ok(__FieldTag::__fhir_matcher),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::batch_get_documents_metadata_request::Matcher;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Matcher")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__uris_matcher => {
if !fields.insert(__FieldTag::__uris_matcher) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for uris_matcher",
));
}
if result.matcher.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `matcher`, a oneof with full ID .google.cloud.discoveryengine.v1.BatchGetDocumentsMetadataRequest.Matcher.uris_matcher, latest field was urisMatcher",
));
}
result.matcher = std::option::Option::Some(
crate::model::batch_get_documents_metadata_request::matcher::Matcher::UrisMatcher(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::batch_get_documents_metadata_request::UrisMatcher>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__fhir_matcher => {
if !fields.insert(__FieldTag::__fhir_matcher) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for fhir_matcher",
));
}
if result.matcher.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `matcher`, a oneof with full ID .google.cloud.discoveryengine.v1.BatchGetDocumentsMetadataRequest.Matcher.fhir_matcher, latest field was fhirMatcher",
));
}
result.matcher = std::option::Option::Some(
crate::model::batch_get_documents_metadata_request::matcher::Matcher::FhirMatcher(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::batch_get_documents_metadata_request::FhirMatcher>>>()?.unwrap_or_default()
),
);
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "document-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::BatchGetDocumentsMetadataResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__documents_metadata,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for BatchGetDocumentsMetadataResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"documentsMetadata" => Ok(__FieldTag::__documents_metadata),
"documents_metadata" => Ok(__FieldTag::__documents_metadata),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::BatchGetDocumentsMetadataResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BatchGetDocumentsMetadataResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__documents_metadata => {
if !fields.insert(__FieldTag::__documents_metadata) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for documents_metadata",
));
}
result.documents_metadata = map.next_value::<std::option::Option<std::vec::Vec<crate::model::batch_get_documents_metadata_response::DocumentMetadata>>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "document-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::batch_get_documents_metadata_response::DocumentMetadata
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__matcher_value,
__state,
__last_refreshed_time,
__data_ingestion_source,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DocumentMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"matcherValue" => Ok(__FieldTag::__matcher_value),
"matcher_value" => Ok(__FieldTag::__matcher_value),
"state" => Ok(__FieldTag::__state),
"lastRefreshedTime" => Ok(__FieldTag::__last_refreshed_time),
"last_refreshed_time" => Ok(__FieldTag::__last_refreshed_time),
"dataIngestionSource" => Ok(__FieldTag::__data_ingestion_source),
"data_ingestion_source" => Ok(__FieldTag::__data_ingestion_source),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::batch_get_documents_metadata_response::DocumentMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DocumentMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__matcher_value => {
if !fields.insert(__FieldTag::__matcher_value) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for matcher_value",
));
}
result.matcher_value = map.next_value::<std::option::Option<crate::model::batch_get_documents_metadata_response::document_metadata::MatcherValue>>()?
;
}
__FieldTag::__state => {
if !fields.insert(__FieldTag::__state) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for state",
));
}
result.state = map
.next_value::<std::option::Option<
crate::model::batch_get_documents_metadata_response::State,
>>()?
.unwrap_or_default();
}
__FieldTag::__last_refreshed_time => {
if !fields.insert(__FieldTag::__last_refreshed_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for last_refreshed_time",
));
}
result.last_refreshed_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__data_ingestion_source => {
if !fields.insert(__FieldTag::__data_ingestion_source) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for data_ingestion_source",
));
}
result.data_ingestion_source = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "document-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::batch_get_documents_metadata_response::document_metadata::MatcherValue
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__uri,
__fhir_resource,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for MatcherValue")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"uri" => Ok(__FieldTag::__uri),
"fhirResource" => Ok(__FieldTag::__fhir_resource),
"fhir_resource" => Ok(__FieldTag::__fhir_resource),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value =
super::batch_get_documents_metadata_response::document_metadata::MatcherValue;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct MatcherValue")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__uri => {
if !fields.insert(__FieldTag::__uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for uri",
));
}
if result.matcher_value.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `matcher_value`, a oneof with full ID .google.cloud.discoveryengine.v1.BatchGetDocumentsMetadataResponse.DocumentMetadata.MatcherValue.uri, latest field was uri",
));
}
result.matcher_value = std::option::Option::Some(
crate::model::batch_get_documents_metadata_response::document_metadata::matcher_value::MatcherValue::Uri(
map.next_value::<std::option::Option<std::string::String>>()?.unwrap_or_default()
),
);
}
__FieldTag::__fhir_resource => {
if !fields.insert(__FieldTag::__fhir_resource) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for fhir_resource",
));
}
if result.matcher_value.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `matcher_value`, a oneof with full ID .google.cloud.discoveryengine.v1.BatchGetDocumentsMetadataResponse.DocumentMetadata.MatcherValue.fhir_resource, latest field was fhirResource",
));
}
result.matcher_value = std::option::Option::Some(
crate::model::batch_get_documents_metadata_response::document_metadata::matcher_value::MatcherValue::FhirResource(
map.next_value::<std::option::Option<std::string::String>>()?.unwrap_or_default()
),
);
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::Engine {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__chat_engine_config,
__search_engine_config,
__media_recommendation_engine_config,
__chat_engine_metadata,
__name,
__display_name,
__create_time,
__update_time,
__data_store_ids,
__solution_type,
__industry_vertical,
__common_config,
__disable_analytics,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Engine")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"chatEngineConfig" => Ok(__FieldTag::__chat_engine_config),
"chat_engine_config" => Ok(__FieldTag::__chat_engine_config),
"searchEngineConfig" => Ok(__FieldTag::__search_engine_config),
"search_engine_config" => Ok(__FieldTag::__search_engine_config),
"mediaRecommendationEngineConfig" => {
Ok(__FieldTag::__media_recommendation_engine_config)
}
"media_recommendation_engine_config" => {
Ok(__FieldTag::__media_recommendation_engine_config)
}
"chatEngineMetadata" => Ok(__FieldTag::__chat_engine_metadata),
"chat_engine_metadata" => Ok(__FieldTag::__chat_engine_metadata),
"name" => Ok(__FieldTag::__name),
"displayName" => Ok(__FieldTag::__display_name),
"display_name" => Ok(__FieldTag::__display_name),
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"updateTime" => Ok(__FieldTag::__update_time),
"update_time" => Ok(__FieldTag::__update_time),
"dataStoreIds" => Ok(__FieldTag::__data_store_ids),
"data_store_ids" => Ok(__FieldTag::__data_store_ids),
"solutionType" => Ok(__FieldTag::__solution_type),
"solution_type" => Ok(__FieldTag::__solution_type),
"industryVertical" => Ok(__FieldTag::__industry_vertical),
"industry_vertical" => Ok(__FieldTag::__industry_vertical),
"commonConfig" => Ok(__FieldTag::__common_config),
"common_config" => Ok(__FieldTag::__common_config),
"disableAnalytics" => Ok(__FieldTag::__disable_analytics),
"disable_analytics" => Ok(__FieldTag::__disable_analytics),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Engine;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Engine")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__chat_engine_config => {
if !fields.insert(__FieldTag::__chat_engine_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for chat_engine_config",
));
}
if result.engine_config.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `engine_config`, a oneof with full ID .google.cloud.discoveryengine.v1.Engine.chat_engine_config, latest field was chatEngineConfig",
));
}
result.engine_config = std::option::Option::Some(
crate::model::engine::EngineConfig::ChatEngineConfig(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::engine::ChatEngineConfig>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__search_engine_config => {
if !fields.insert(__FieldTag::__search_engine_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for search_engine_config",
));
}
if result.engine_config.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `engine_config`, a oneof with full ID .google.cloud.discoveryengine.v1.Engine.search_engine_config, latest field was searchEngineConfig",
));
}
result.engine_config = std::option::Option::Some(
crate::model::engine::EngineConfig::SearchEngineConfig(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::engine::SearchEngineConfig>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__media_recommendation_engine_config => {
if !fields.insert(__FieldTag::__media_recommendation_engine_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for media_recommendation_engine_config",
));
}
if result.engine_config.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `engine_config`, a oneof with full ID .google.cloud.discoveryengine.v1.Engine.media_recommendation_engine_config, latest field was mediaRecommendationEngineConfig",
));
}
result.engine_config = std::option::Option::Some(
crate::model::engine::EngineConfig::MediaRecommendationEngineConfig(
map.next_value::<std::option::Option<
std::boxed::Box<
crate::model::engine::MediaRecommendationEngineConfig,
>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__chat_engine_metadata => {
if !fields.insert(__FieldTag::__chat_engine_metadata) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for chat_engine_metadata",
));
}
if result.engine_metadata.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `engine_metadata`, a oneof with full ID .google.cloud.discoveryengine.v1.Engine.chat_engine_metadata, latest field was chatEngineMetadata",
));
}
result.engine_metadata = std::option::Option::Some(
crate::model::engine::EngineMetadata::ChatEngineMetadata(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::engine::ChatEngineMetadata>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__display_name => {
if !fields.insert(__FieldTag::__display_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for display_name",
));
}
result.display_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__update_time => {
if !fields.insert(__FieldTag::__update_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_time",
));
}
result.update_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__data_store_ids => {
if !fields.insert(__FieldTag::__data_store_ids) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for data_store_ids",
));
}
result.data_store_ids = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__solution_type => {
if !fields.insert(__FieldTag::__solution_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for solution_type",
));
}
result.solution_type = map
.next_value::<std::option::Option<crate::model::SolutionType>>()?
.unwrap_or_default();
}
__FieldTag::__industry_vertical => {
if !fields.insert(__FieldTag::__industry_vertical) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for industry_vertical",
));
}
result.industry_vertical = map
.next_value::<std::option::Option<crate::model::IndustryVertical>>(
)?
.unwrap_or_default();
}
__FieldTag::__common_config => {
if !fields.insert(__FieldTag::__common_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for common_config",
));
}
result.common_config = map.next_value::<std::option::Option<crate::model::engine::CommonConfig>>()?
;
}
__FieldTag::__disable_analytics => {
if !fields.insert(__FieldTag::__disable_analytics) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for disable_analytics",
));
}
result.disable_analytics = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::engine::SearchEngineConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__search_tier,
__search_add_ons,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SearchEngineConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"searchTier" => Ok(__FieldTag::__search_tier),
"search_tier" => Ok(__FieldTag::__search_tier),
"searchAddOns" => Ok(__FieldTag::__search_add_ons),
"search_add_ons" => Ok(__FieldTag::__search_add_ons),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::engine::SearchEngineConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SearchEngineConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__search_tier => {
if !fields.insert(__FieldTag::__search_tier) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for search_tier",
));
}
result.search_tier = map
.next_value::<std::option::Option<crate::model::SearchTier>>()?
.unwrap_or_default();
}
__FieldTag::__search_add_ons => {
if !fields.insert(__FieldTag::__search_add_ons) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for search_add_ons",
));
}
result.search_add_ons = map.next_value::<std::option::Option<std::vec::Vec<crate::model::SearchAddOn>>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::engine::MediaRecommendationEngineConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__type,
__optimization_objective,
__optimization_objective_config,
__training_state,
__engine_features_config,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for MediaRecommendationEngineConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"type" => Ok(__FieldTag::__type),
"optimizationObjective" => Ok(__FieldTag::__optimization_objective),
"optimization_objective" => Ok(__FieldTag::__optimization_objective),
"optimizationObjectiveConfig" => {
Ok(__FieldTag::__optimization_objective_config)
}
"optimization_objective_config" => {
Ok(__FieldTag::__optimization_objective_config)
}
"trainingState" => Ok(__FieldTag::__training_state),
"training_state" => Ok(__FieldTag::__training_state),
"engineFeaturesConfig" => Ok(__FieldTag::__engine_features_config),
"engine_features_config" => Ok(__FieldTag::__engine_features_config),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::engine::MediaRecommendationEngineConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct MediaRecommendationEngineConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__type => {
if !fields.insert(__FieldTag::__type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for type",
));
}
result.r#type = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__optimization_objective => {
if !fields.insert(__FieldTag::__optimization_objective) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for optimization_objective",
));
}
result.optimization_objective = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__optimization_objective_config => {
if !fields.insert(__FieldTag::__optimization_objective_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for optimization_objective_config",
));
}
result.optimization_objective_config = map.next_value::<std::option::Option<crate::model::engine::media_recommendation_engine_config::OptimizationObjectiveConfig>>()?
;
}
__FieldTag::__training_state => {
if !fields.insert(__FieldTag::__training_state) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for training_state",
));
}
result.training_state = map.next_value::<std::option::Option<crate::model::engine::media_recommendation_engine_config::TrainingState>>()?.unwrap_or_default();
}
__FieldTag::__engine_features_config => {
if !fields.insert(__FieldTag::__engine_features_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for engine_features_config",
));
}
result.engine_features_config = map.next_value::<std::option::Option<crate::model::engine::media_recommendation_engine_config::EngineFeaturesConfig>>()?
;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::engine::media_recommendation_engine_config::OptimizationObjectiveConfig
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__target_field,
__target_field_value_float,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for OptimizationObjectiveConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"targetField" => Ok(__FieldTag::__target_field),
"target_field" => Ok(__FieldTag::__target_field),
"targetFieldValueFloat" => Ok(__FieldTag::__target_field_value_float),
"target_field_value_float" => {
Ok(__FieldTag::__target_field_value_float)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value =
super::engine::media_recommendation_engine_config::OptimizationObjectiveConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct OptimizationObjectiveConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__target_field => {
if !fields.insert(__FieldTag::__target_field) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for target_field",
));
}
result.target_field = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__target_field_value_float => {
if !fields.insert(__FieldTag::__target_field_value_float) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for target_field_value_float",
));
}
struct __With(std::option::Option<f32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F32> >::deserialize(deserializer).map(__With)
}
}
result.target_field_value_float =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::engine::media_recommendation_engine_config::EngineFeaturesConfig
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__recommended_for_you_config,
__most_popular_config,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for EngineFeaturesConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"recommendedForYouConfig" => {
Ok(__FieldTag::__recommended_for_you_config)
}
"recommended_for_you_config" => {
Ok(__FieldTag::__recommended_for_you_config)
}
"mostPopularConfig" => Ok(__FieldTag::__most_popular_config),
"most_popular_config" => Ok(__FieldTag::__most_popular_config),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::engine::media_recommendation_engine_config::EngineFeaturesConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct EngineFeaturesConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__recommended_for_you_config => {
if !fields.insert(__FieldTag::__recommended_for_you_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for recommended_for_you_config",
));
}
if result.type_dedicated_config.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `type_dedicated_config`, a oneof with full ID .google.cloud.discoveryengine.v1.Engine.MediaRecommendationEngineConfig.EngineFeaturesConfig.recommended_for_you_config, latest field was recommendedForYouConfig",
));
}
result.type_dedicated_config = std::option::Option::Some(
crate::model::engine::media_recommendation_engine_config::engine_features_config::TypeDedicatedConfig::RecommendedForYouConfig(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::engine::media_recommendation_engine_config::RecommendedForYouFeatureConfig>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__most_popular_config => {
if !fields.insert(__FieldTag::__most_popular_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for most_popular_config",
));
}
if result.type_dedicated_config.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `type_dedicated_config`, a oneof with full ID .google.cloud.discoveryengine.v1.Engine.MediaRecommendationEngineConfig.EngineFeaturesConfig.most_popular_config, latest field was mostPopularConfig",
));
}
result.type_dedicated_config = std::option::Option::Some(
crate::model::engine::media_recommendation_engine_config::engine_features_config::TypeDedicatedConfig::MostPopularConfig(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::engine::media_recommendation_engine_config::MostPopularFeatureConfig>>>()?.unwrap_or_default()
),
);
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::engine::media_recommendation_engine_config::RecommendedForYouFeatureConfig
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__context_event_type,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for RecommendedForYouFeatureConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"contextEventType" => Ok(__FieldTag::__context_event_type),
"context_event_type" => Ok(__FieldTag::__context_event_type),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value =
super::engine::media_recommendation_engine_config::RecommendedForYouFeatureConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct RecommendedForYouFeatureConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__context_event_type => {
if !fields.insert(__FieldTag::__context_event_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for context_event_type",
));
}
result.context_event_type = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::engine::media_recommendation_engine_config::MostPopularFeatureConfig
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__time_window_days,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for MostPopularFeatureConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"timeWindowDays" => Ok(__FieldTag::__time_window_days),
"time_window_days" => Ok(__FieldTag::__time_window_days),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value =
super::engine::media_recommendation_engine_config::MostPopularFeatureConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct MostPopularFeatureConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__time_window_days => {
if !fields.insert(__FieldTag::__time_window_days) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for time_window_days",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.time_window_days =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::engine::ChatEngineConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__agent_creation_config,
__dialogflow_agent_to_link,
__allow_cross_region,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ChatEngineConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"agentCreationConfig" => Ok(__FieldTag::__agent_creation_config),
"agent_creation_config" => Ok(__FieldTag::__agent_creation_config),
"dialogflowAgentToLink" => Ok(__FieldTag::__dialogflow_agent_to_link),
"dialogflow_agent_to_link" => {
Ok(__FieldTag::__dialogflow_agent_to_link)
}
"allowCrossRegion" => Ok(__FieldTag::__allow_cross_region),
"allow_cross_region" => Ok(__FieldTag::__allow_cross_region),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::engine::ChatEngineConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ChatEngineConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__agent_creation_config => {
if !fields.insert(__FieldTag::__agent_creation_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for agent_creation_config",
));
}
result.agent_creation_config = map.next_value::<std::option::Option<
crate::model::engine::chat_engine_config::AgentCreationConfig,
>>()?;
}
__FieldTag::__dialogflow_agent_to_link => {
if !fields.insert(__FieldTag::__dialogflow_agent_to_link) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for dialogflow_agent_to_link",
));
}
result.dialogflow_agent_to_link = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__allow_cross_region => {
if !fields.insert(__FieldTag::__allow_cross_region) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for allow_cross_region",
));
}
result.allow_cross_region = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::engine::chat_engine_config::AgentCreationConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__business,
__default_language_code,
__time_zone,
__location,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for AgentCreationConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"business" => Ok(__FieldTag::__business),
"defaultLanguageCode" => Ok(__FieldTag::__default_language_code),
"default_language_code" => Ok(__FieldTag::__default_language_code),
"timeZone" => Ok(__FieldTag::__time_zone),
"time_zone" => Ok(__FieldTag::__time_zone),
"location" => Ok(__FieldTag::__location),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::engine::chat_engine_config::AgentCreationConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct AgentCreationConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__business => {
if !fields.insert(__FieldTag::__business) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for business",
));
}
result.business = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__default_language_code => {
if !fields.insert(__FieldTag::__default_language_code) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for default_language_code",
));
}
result.default_language_code = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__time_zone => {
if !fields.insert(__FieldTag::__time_zone) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for time_zone",
));
}
result.time_zone = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__location => {
if !fields.insert(__FieldTag::__location) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for location",
));
}
result.location = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::engine::CommonConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__company_name,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for CommonConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"companyName" => Ok(__FieldTag::__company_name),
"company_name" => Ok(__FieldTag::__company_name),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::engine::CommonConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CommonConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__company_name => {
if !fields.insert(__FieldTag::__company_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for company_name",
));
}
result.company_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::engine::ChatEngineMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__dialogflow_agent,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ChatEngineMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"dialogflowAgent" => Ok(__FieldTag::__dialogflow_agent),
"dialogflow_agent" => Ok(__FieldTag::__dialogflow_agent),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::engine::ChatEngineMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ChatEngineMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__dialogflow_agent => {
if !fields.insert(__FieldTag::__dialogflow_agent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for dialogflow_agent",
));
}
result.dialogflow_agent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::CreateEngineRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__parent,
__engine,
__engine_id,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for CreateEngineRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"parent" => Ok(__FieldTag::__parent),
"engine" => Ok(__FieldTag::__engine),
"engineId" => Ok(__FieldTag::__engine_id),
"engine_id" => Ok(__FieldTag::__engine_id),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CreateEngineRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CreateEngineRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__engine => {
if !fields.insert(__FieldTag::__engine) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for engine",
));
}
result.engine =
map.next_value::<std::option::Option<crate::model::Engine>>()?;
}
__FieldTag::__engine_id => {
if !fields.insert(__FieldTag::__engine_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for engine_id",
));
}
result.engine_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::CreateEngineMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__create_time,
__update_time,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for CreateEngineMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"updateTime" => Ok(__FieldTag::__update_time),
"update_time" => Ok(__FieldTag::__update_time),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CreateEngineMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CreateEngineMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__update_time => {
if !fields.insert(__FieldTag::__update_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_time",
));
}
result.update_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::DeleteEngineRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DeleteEngineRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DeleteEngineRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DeleteEngineRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::DeleteEngineMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__create_time,
__update_time,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DeleteEngineMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"updateTime" => Ok(__FieldTag::__update_time),
"update_time" => Ok(__FieldTag::__update_time),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DeleteEngineMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DeleteEngineMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__update_time => {
if !fields.insert(__FieldTag::__update_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_time",
));
}
result.update_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::GetEngineRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for GetEngineRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::GetEngineRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GetEngineRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ListEnginesRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__parent,
__page_size,
__page_token,
__filter,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ListEnginesRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"parent" => Ok(__FieldTag::__parent),
"pageSize" => Ok(__FieldTag::__page_size),
"page_size" => Ok(__FieldTag::__page_size),
"pageToken" => Ok(__FieldTag::__page_token),
"page_token" => Ok(__FieldTag::__page_token),
"filter" => Ok(__FieldTag::__filter),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListEnginesRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListEnginesRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__page_size => {
if !fields.insert(__FieldTag::__page_size) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_size",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.page_size = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__page_token => {
if !fields.insert(__FieldTag::__page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_token",
));
}
result.page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__filter => {
if !fields.insert(__FieldTag::__filter) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for filter",
));
}
result.filter = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ListEnginesResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__engines,
__next_page_token,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ListEnginesResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"engines" => Ok(__FieldTag::__engines),
"nextPageToken" => Ok(__FieldTag::__next_page_token),
"next_page_token" => Ok(__FieldTag::__next_page_token),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListEnginesResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListEnginesResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__engines => {
if !fields.insert(__FieldTag::__engines) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for engines",
));
}
result.engines = map.next_value::<std::option::Option<std::vec::Vec<crate::model::Engine>>>()?.unwrap_or_default();
}
__FieldTag::__next_page_token => {
if !fields.insert(__FieldTag::__next_page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for next_page_token",
));
}
result.next_page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::UpdateEngineRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__engine,
__update_mask,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for UpdateEngineRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"engine" => Ok(__FieldTag::__engine),
"updateMask" => Ok(__FieldTag::__update_mask),
"update_mask" => Ok(__FieldTag::__update_mask),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::UpdateEngineRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct UpdateEngineRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__engine => {
if !fields.insert(__FieldTag::__engine) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for engine",
));
}
result.engine =
map.next_value::<std::option::Option<crate::model::Engine>>()?;
}
__FieldTag::__update_mask => {
if !fields.insert(__FieldTag::__update_mask) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_mask",
));
}
result.update_mask =
map.next_value::<std::option::Option<wkt::FieldMask>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "grounded-generation-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::GroundedGenerationContent {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__role,
__parts,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for GroundedGenerationContent")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"role" => Ok(__FieldTag::__role),
"parts" => Ok(__FieldTag::__parts),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::GroundedGenerationContent;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GroundedGenerationContent")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__role => {
if !fields.insert(__FieldTag::__role) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for role",
));
}
result.role = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__parts => {
if !fields.insert(__FieldTag::__parts) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parts",
));
}
result.parts = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::grounded_generation_content::Part>,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "grounded-generation-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::grounded_generation_content::Part {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__text,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Part")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"text" => Ok(__FieldTag::__text),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::grounded_generation_content::Part;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Part")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__text => {
if !fields.insert(__FieldTag::__text) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for text",
));
}
if result.data.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `data`, a oneof with full ID .google.cloud.discoveryengine.v1.GroundedGenerationContent.Part.text, latest field was text",
));
}
result.data = std::option::Option::Some(
crate::model::grounded_generation_content::part::Data::Text(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "grounded-generation-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::GenerateGroundedContentRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__location,
__system_instruction,
__contents,
__generation_spec,
__grounding_spec,
__user_labels,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for GenerateGroundedContentRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"location" => Ok(__FieldTag::__location),
"systemInstruction" => Ok(__FieldTag::__system_instruction),
"system_instruction" => Ok(__FieldTag::__system_instruction),
"contents" => Ok(__FieldTag::__contents),
"generationSpec" => Ok(__FieldTag::__generation_spec),
"generation_spec" => Ok(__FieldTag::__generation_spec),
"groundingSpec" => Ok(__FieldTag::__grounding_spec),
"grounding_spec" => Ok(__FieldTag::__grounding_spec),
"userLabels" => Ok(__FieldTag::__user_labels),
"user_labels" => Ok(__FieldTag::__user_labels),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::GenerateGroundedContentRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GenerateGroundedContentRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__location => {
if !fields.insert(__FieldTag::__location) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for location",
));
}
result.location = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__system_instruction => {
if !fields.insert(__FieldTag::__system_instruction) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for system_instruction",
));
}
result.system_instruction = map.next_value::<std::option::Option<crate::model::GroundedGenerationContent>>()?
;
}
__FieldTag::__contents => {
if !fields.insert(__FieldTag::__contents) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for contents",
));
}
result.contents = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::GroundedGenerationContent>,
>>()?
.unwrap_or_default();
}
__FieldTag::__generation_spec => {
if !fields.insert(__FieldTag::__generation_spec) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for generation_spec",
));
}
result.generation_spec = map.next_value::<std::option::Option<
crate::model::generate_grounded_content_request::GenerationSpec,
>>()?;
}
__FieldTag::__grounding_spec => {
if !fields.insert(__FieldTag::__grounding_spec) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for grounding_spec",
));
}
result.grounding_spec = map.next_value::<std::option::Option<
crate::model::generate_grounded_content_request::GroundingSpec,
>>()?;
}
__FieldTag::__user_labels => {
if !fields.insert(__FieldTag::__user_labels) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for user_labels",
));
}
result.user_labels = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
std::string::String,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "grounded-generation-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::generate_grounded_content_request::GenerationSpec {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__model_id,
__language_code,
__temperature,
__top_p,
__top_k,
__frequency_penalty,
__seed,
__presence_penalty,
__max_output_tokens,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for GenerationSpec")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"modelId" => Ok(__FieldTag::__model_id),
"model_id" => Ok(__FieldTag::__model_id),
"languageCode" => Ok(__FieldTag::__language_code),
"language_code" => Ok(__FieldTag::__language_code),
"temperature" => Ok(__FieldTag::__temperature),
"topP" => Ok(__FieldTag::__top_p),
"top_p" => Ok(__FieldTag::__top_p),
"topK" => Ok(__FieldTag::__top_k),
"top_k" => Ok(__FieldTag::__top_k),
"frequencyPenalty" => Ok(__FieldTag::__frequency_penalty),
"frequency_penalty" => Ok(__FieldTag::__frequency_penalty),
"seed" => Ok(__FieldTag::__seed),
"presencePenalty" => Ok(__FieldTag::__presence_penalty),
"presence_penalty" => Ok(__FieldTag::__presence_penalty),
"maxOutputTokens" => Ok(__FieldTag::__max_output_tokens),
"max_output_tokens" => Ok(__FieldTag::__max_output_tokens),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::generate_grounded_content_request::GenerationSpec;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GenerationSpec")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__model_id => {
if !fields.insert(__FieldTag::__model_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for model_id",
));
}
result.model_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__language_code => {
if !fields.insert(__FieldTag::__language_code) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for language_code",
));
}
result.language_code = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__temperature => {
if !fields.insert(__FieldTag::__temperature) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for temperature",
));
}
struct __With(std::option::Option<f32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F32> >::deserialize(deserializer).map(__With)
}
}
result.temperature = map.next_value::<__With>()?.0;
}
__FieldTag::__top_p => {
if !fields.insert(__FieldTag::__top_p) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for top_p",
));
}
struct __With(std::option::Option<f32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F32> >::deserialize(deserializer).map(__With)
}
}
result.top_p = map.next_value::<__With>()?.0;
}
__FieldTag::__top_k => {
if !fields.insert(__FieldTag::__top_k) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for top_k",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.top_k = map.next_value::<__With>()?.0;
}
__FieldTag::__frequency_penalty => {
if !fields.insert(__FieldTag::__frequency_penalty) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for frequency_penalty",
));
}
struct __With(std::option::Option<f32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F32> >::deserialize(deserializer).map(__With)
}
}
result.frequency_penalty = map.next_value::<__With>()?.0;
}
__FieldTag::__seed => {
if !fields.insert(__FieldTag::__seed) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for seed",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.seed = map.next_value::<__With>()?.0;
}
__FieldTag::__presence_penalty => {
if !fields.insert(__FieldTag::__presence_penalty) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for presence_penalty",
));
}
struct __With(std::option::Option<f32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F32> >::deserialize(deserializer).map(__With)
}
}
result.presence_penalty = map.next_value::<__With>()?.0;
}
__FieldTag::__max_output_tokens => {
if !fields.insert(__FieldTag::__max_output_tokens) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for max_output_tokens",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.max_output_tokens = map.next_value::<__With>()?.0;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "grounded-generation-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::generate_grounded_content_request::DynamicRetrievalConfiguration
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__predictor,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DynamicRetrievalConfiguration")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"predictor" => Ok(__FieldTag::__predictor),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::generate_grounded_content_request::DynamicRetrievalConfiguration;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DynamicRetrievalConfiguration")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__predictor => {
if !fields.insert(__FieldTag::__predictor) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for predictor",
));
}
result.predictor = map.next_value::<std::option::Option<crate::model::generate_grounded_content_request::dynamic_retrieval_configuration::DynamicRetrievalPredictor>>()?
;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "grounded-generation-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::generate_grounded_content_request::dynamic_retrieval_configuration::DynamicRetrievalPredictor {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__version,
__threshold,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DynamicRetrievalPredictor")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"version" => Ok(__FieldTag::__version),
"threshold" => Ok(__FieldTag::__threshold),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::generate_grounded_content_request::dynamic_retrieval_configuration::DynamicRetrievalPredictor;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DynamicRetrievalPredictor")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
use std::option::Option::Some;
#[allow(unused_imports)]
use serde::de::Error;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__version => {
if !fields.insert(__FieldTag::__version) {
return std::result::Result::Err(A::Error::duplicate_field("multiple values for version"));
}
result.version = map.next_value::<std::option::Option<crate::model::generate_grounded_content_request::dynamic_retrieval_configuration::dynamic_retrieval_predictor::Version>>()?.unwrap_or_default();
},
__FieldTag::__threshold => {
if !fields.insert(__FieldTag::__threshold) {
return std::result::Result::Err(A::Error::duplicate_field("multiple values for threshold"));
}
struct __With( std::option::Option<f32> );
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F32> >::deserialize(deserializer).map(__With)
}
}
result.threshold = map.next_value::< __With >()?.0;
},
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
},
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "grounded-generation-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::generate_grounded_content_request::GroundingSource
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__inline_source,
__search_source,
__google_search_source,
__enterprise_web_retrieval_source,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for GroundingSource")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"inlineSource" => Ok(__FieldTag::__inline_source),
"inline_source" => Ok(__FieldTag::__inline_source),
"searchSource" => Ok(__FieldTag::__search_source),
"search_source" => Ok(__FieldTag::__search_source),
"googleSearchSource" => Ok(__FieldTag::__google_search_source),
"google_search_source" => Ok(__FieldTag::__google_search_source),
"enterpriseWebRetrievalSource" => {
Ok(__FieldTag::__enterprise_web_retrieval_source)
}
"enterprise_web_retrieval_source" => {
Ok(__FieldTag::__enterprise_web_retrieval_source)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::generate_grounded_content_request::GroundingSource;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GroundingSource")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__inline_source => {
if !fields.insert(__FieldTag::__inline_source) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for inline_source",
));
}
if result.source.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `source`, a oneof with full ID .google.cloud.discoveryengine.v1.GenerateGroundedContentRequest.GroundingSource.inline_source, latest field was inlineSource",
));
}
result.source = std::option::Option::Some(
crate::model::generate_grounded_content_request::grounding_source::Source::InlineSource(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::generate_grounded_content_request::grounding_source::InlineSource>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__search_source => {
if !fields.insert(__FieldTag::__search_source) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for search_source",
));
}
if result.source.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `source`, a oneof with full ID .google.cloud.discoveryengine.v1.GenerateGroundedContentRequest.GroundingSource.search_source, latest field was searchSource",
));
}
result.source = std::option::Option::Some(
crate::model::generate_grounded_content_request::grounding_source::Source::SearchSource(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::generate_grounded_content_request::grounding_source::SearchSource>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__google_search_source => {
if !fields.insert(__FieldTag::__google_search_source) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for google_search_source",
));
}
if result.source.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `source`, a oneof with full ID .google.cloud.discoveryengine.v1.GenerateGroundedContentRequest.GroundingSource.google_search_source, latest field was googleSearchSource",
));
}
result.source = std::option::Option::Some(
crate::model::generate_grounded_content_request::grounding_source::Source::GoogleSearchSource(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::generate_grounded_content_request::grounding_source::GoogleSearchSource>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__enterprise_web_retrieval_source => {
if !fields.insert(__FieldTag::__enterprise_web_retrieval_source) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for enterprise_web_retrieval_source",
));
}
if result.source.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `source`, a oneof with full ID .google.cloud.discoveryengine.v1.GenerateGroundedContentRequest.GroundingSource.enterprise_web_retrieval_source, latest field was enterpriseWebRetrievalSource",
));
}
result.source = std::option::Option::Some(
crate::model::generate_grounded_content_request::grounding_source::Source::EnterpriseWebRetrievalSource(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::generate_grounded_content_request::grounding_source::EnterpriseWebRetrievalSource>>>()?.unwrap_or_default()
),
);
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "grounded-generation-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::generate_grounded_content_request::grounding_source::InlineSource
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__grounding_facts,
__attributes,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for InlineSource")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"groundingFacts" => Ok(__FieldTag::__grounding_facts),
"grounding_facts" => Ok(__FieldTag::__grounding_facts),
"attributes" => Ok(__FieldTag::__attributes),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::generate_grounded_content_request::grounding_source::InlineSource;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct InlineSource")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__grounding_facts => {
if !fields.insert(__FieldTag::__grounding_facts) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for grounding_facts",
));
}
result.grounding_facts = map.next_value::<std::option::Option<std::vec::Vec<crate::model::GroundingFact>>>()?.unwrap_or_default();
}
__FieldTag::__attributes => {
if !fields.insert(__FieldTag::__attributes) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for attributes",
));
}
result.attributes = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
std::string::String,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "grounded-generation-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::generate_grounded_content_request::grounding_source::SearchSource
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__serving_config,
__max_result_count,
__filter,
__safe_search,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SearchSource")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"servingConfig" => Ok(__FieldTag::__serving_config),
"serving_config" => Ok(__FieldTag::__serving_config),
"maxResultCount" => Ok(__FieldTag::__max_result_count),
"max_result_count" => Ok(__FieldTag::__max_result_count),
"filter" => Ok(__FieldTag::__filter),
"safeSearch" => Ok(__FieldTag::__safe_search),
"safe_search" => Ok(__FieldTag::__safe_search),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::generate_grounded_content_request::grounding_source::SearchSource;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SearchSource")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__serving_config => {
if !fields.insert(__FieldTag::__serving_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for serving_config",
));
}
result.serving_config = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__max_result_count => {
if !fields.insert(__FieldTag::__max_result_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for max_result_count",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.max_result_count =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__filter => {
if !fields.insert(__FieldTag::__filter) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for filter",
));
}
result.filter = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__safe_search => {
if !fields.insert(__FieldTag::__safe_search) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for safe_search",
));
}
result.safe_search = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "grounded-generation-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::generate_grounded_content_request::grounding_source::GoogleSearchSource
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__dynamic_retrieval_config,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for GoogleSearchSource")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"dynamicRetrievalConfig" => Ok(__FieldTag::__dynamic_retrieval_config),
"dynamic_retrieval_config" => {
Ok(__FieldTag::__dynamic_retrieval_config)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value =
super::generate_grounded_content_request::grounding_source::GoogleSearchSource;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GoogleSearchSource")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__dynamic_retrieval_config => {
if !fields.insert(__FieldTag::__dynamic_retrieval_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for dynamic_retrieval_config",
));
}
result.dynamic_retrieval_config = map.next_value::<std::option::Option<crate::model::generate_grounded_content_request::DynamicRetrievalConfiguration>>()?
;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "grounded-generation-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::generate_grounded_content_request::grounding_source::EnterpriseWebRetrievalSource
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for EnterpriseWebRetrievalSource")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
Ok(__FieldTag::Unknown(value.to_string()))
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::generate_grounded_content_request::grounding_source::EnterpriseWebRetrievalSource;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct EnterpriseWebRetrievalSource")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "grounded-generation-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::generate_grounded_content_request::GroundingSpec {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__grounding_sources,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for GroundingSpec")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"groundingSources" => Ok(__FieldTag::__grounding_sources),
"grounding_sources" => Ok(__FieldTag::__grounding_sources),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::generate_grounded_content_request::GroundingSpec;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GroundingSpec")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__grounding_sources => {
if !fields.insert(__FieldTag::__grounding_sources) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for grounding_sources",
));
}
result.grounding_sources = map.next_value::<std::option::Option<std::vec::Vec<crate::model::generate_grounded_content_request::GroundingSource>>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "grounded-generation-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::GenerateGroundedContentResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__candidates,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for GenerateGroundedContentResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"candidates" => Ok(__FieldTag::__candidates),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::GenerateGroundedContentResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GenerateGroundedContentResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__candidates => {
if !fields.insert(__FieldTag::__candidates) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for candidates",
));
}
result.candidates = map
.next_value::<std::option::Option<
std::vec::Vec<
crate::model::generate_grounded_content_response::Candidate,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "grounded-generation-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::generate_grounded_content_response::Candidate {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__index,
__content,
__grounding_score,
__grounding_metadata,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Candidate")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"index" => Ok(__FieldTag::__index),
"content" => Ok(__FieldTag::__content),
"groundingScore" => Ok(__FieldTag::__grounding_score),
"grounding_score" => Ok(__FieldTag::__grounding_score),
"groundingMetadata" => Ok(__FieldTag::__grounding_metadata),
"grounding_metadata" => Ok(__FieldTag::__grounding_metadata),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::generate_grounded_content_response::Candidate;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Candidate")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__index => {
if !fields.insert(__FieldTag::__index) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for index",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.index = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__content => {
if !fields.insert(__FieldTag::__content) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for content",
));
}
result.content = map.next_value::<std::option::Option<crate::model::GroundedGenerationContent>>()?
;
}
__FieldTag::__grounding_score => {
if !fields.insert(__FieldTag::__grounding_score) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for grounding_score",
));
}
struct __With(std::option::Option<f32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F32> >::deserialize(deserializer).map(__With)
}
}
result.grounding_score = map.next_value::<__With>()?.0;
}
__FieldTag::__grounding_metadata => {
if !fields.insert(__FieldTag::__grounding_metadata) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for grounding_metadata",
));
}
result.grounding_metadata = map.next_value::<std::option::Option<crate::model::generate_grounded_content_response::candidate::GroundingMetadata>>()?
;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "grounded-generation-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::generate_grounded_content_response::candidate::GroundingMetadata
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__retrieval_metadata,
__support_chunks,
__web_search_queries,
__search_entry_point,
__grounding_support,
__images,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for GroundingMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"retrievalMetadata" => Ok(__FieldTag::__retrieval_metadata),
"retrieval_metadata" => Ok(__FieldTag::__retrieval_metadata),
"supportChunks" => Ok(__FieldTag::__support_chunks),
"support_chunks" => Ok(__FieldTag::__support_chunks),
"webSearchQueries" => Ok(__FieldTag::__web_search_queries),
"web_search_queries" => Ok(__FieldTag::__web_search_queries),
"searchEntryPoint" => Ok(__FieldTag::__search_entry_point),
"search_entry_point" => Ok(__FieldTag::__search_entry_point),
"groundingSupport" => Ok(__FieldTag::__grounding_support),
"grounding_support" => Ok(__FieldTag::__grounding_support),
"images" => Ok(__FieldTag::__images),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::generate_grounded_content_response::candidate::GroundingMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GroundingMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__retrieval_metadata => {
if !fields.insert(__FieldTag::__retrieval_metadata) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for retrieval_metadata",
));
}
result.retrieval_metadata = map.next_value::<std::option::Option<std::vec::Vec<crate::model::generate_grounded_content_response::candidate::grounding_metadata::RetrievalMetadata>>>()?.unwrap_or_default();
}
__FieldTag::__support_chunks => {
if !fields.insert(__FieldTag::__support_chunks) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for support_chunks",
));
}
result.support_chunks = map.next_value::<std::option::Option<std::vec::Vec<crate::model::FactChunk>>>()?.unwrap_or_default();
}
__FieldTag::__web_search_queries => {
if !fields.insert(__FieldTag::__web_search_queries) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for web_search_queries",
));
}
result.web_search_queries = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__search_entry_point => {
if !fields.insert(__FieldTag::__search_entry_point) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for search_entry_point",
));
}
result.search_entry_point = map.next_value::<std::option::Option<crate::model::generate_grounded_content_response::candidate::grounding_metadata::SearchEntryPoint>>()?
;
}
__FieldTag::__grounding_support => {
if !fields.insert(__FieldTag::__grounding_support) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for grounding_support",
));
}
result.grounding_support = map.next_value::<std::option::Option<std::vec::Vec<crate::model::generate_grounded_content_response::candidate::grounding_metadata::GroundingSupport>>>()?.unwrap_or_default();
}
__FieldTag::__images => {
if !fields.insert(__FieldTag::__images) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for images",
));
}
result.images = map.next_value::<std::option::Option<std::vec::Vec<crate::model::generate_grounded_content_response::candidate::grounding_metadata::ImageMetadata>>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "grounded-generation-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::generate_grounded_content_response::candidate::grounding_metadata::RetrievalMetadata
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__source,
__dynamic_retrieval_metadata,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for RetrievalMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"source" => Ok(__FieldTag::__source),
"dynamicRetrievalMetadata" => {
Ok(__FieldTag::__dynamic_retrieval_metadata)
}
"dynamic_retrieval_metadata" => {
Ok(__FieldTag::__dynamic_retrieval_metadata)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::generate_grounded_content_response::candidate::grounding_metadata::RetrievalMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct RetrievalMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__source => {
if !fields.insert(__FieldTag::__source) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for source",
));
}
result.source = map.next_value::<std::option::Option<crate::model::generate_grounded_content_response::candidate::grounding_metadata::retrieval_metadata::Source>>()?.unwrap_or_default();
}
__FieldTag::__dynamic_retrieval_metadata => {
if !fields.insert(__FieldTag::__dynamic_retrieval_metadata) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for dynamic_retrieval_metadata",
));
}
result.dynamic_retrieval_metadata = map.next_value::<std::option::Option<crate::model::generate_grounded_content_response::candidate::grounding_metadata::DynamicRetrievalMetadata>>()?
;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "grounded-generation-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::generate_grounded_content_response::candidate::grounding_metadata::DynamicRetrievalMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__predictor_metadata,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DynamicRetrievalMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"predictorMetadata" => Ok(__FieldTag::__predictor_metadata),
"predictor_metadata" => Ok(__FieldTag::__predictor_metadata),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::generate_grounded_content_response::candidate::grounding_metadata::DynamicRetrievalMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DynamicRetrievalMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
use std::option::Option::Some;
#[allow(unused_imports)]
use serde::de::Error;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__predictor_metadata => {
if !fields.insert(__FieldTag::__predictor_metadata) {
return std::result::Result::Err(A::Error::duplicate_field("multiple values for predictor_metadata"));
}
result.predictor_metadata = map.next_value::<std::option::Option<crate::model::generate_grounded_content_response::candidate::grounding_metadata::DynamicRetrievalPredictorMetadata>>()?
;
},
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
},
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "grounded-generation-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::generate_grounded_content_response::candidate::grounding_metadata::DynamicRetrievalPredictorMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__version,
__prediction,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DynamicRetrievalPredictorMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"version" => Ok(__FieldTag::__version),
"prediction" => Ok(__FieldTag::__prediction),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::generate_grounded_content_response::candidate::grounding_metadata::DynamicRetrievalPredictorMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DynamicRetrievalPredictorMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
use std::option::Option::Some;
#[allow(unused_imports)]
use serde::de::Error;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__version => {
if !fields.insert(__FieldTag::__version) {
return std::result::Result::Err(A::Error::duplicate_field("multiple values for version"));
}
result.version = map.next_value::<std::option::Option<crate::model::generate_grounded_content_response::candidate::grounding_metadata::dynamic_retrieval_predictor_metadata::Version>>()?.unwrap_or_default();
},
__FieldTag::__prediction => {
if !fields.insert(__FieldTag::__prediction) {
return std::result::Result::Err(A::Error::duplicate_field("multiple values for prediction"));
}
struct __With( std::option::Option<f32> );
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F32> >::deserialize(deserializer).map(__With)
}
}
result.prediction = map.next_value::< __With >()?.0;
},
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
},
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "grounded-generation-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::generate_grounded_content_response::candidate::grounding_metadata::SearchEntryPoint
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__rendered_content,
__sdk_blob,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SearchEntryPoint")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"renderedContent" => Ok(__FieldTag::__rendered_content),
"rendered_content" => Ok(__FieldTag::__rendered_content),
"sdkBlob" => Ok(__FieldTag::__sdk_blob),
"sdk_blob" => Ok(__FieldTag::__sdk_blob),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::generate_grounded_content_response::candidate::grounding_metadata::SearchEntryPoint;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SearchEntryPoint")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__rendered_content => {
if !fields.insert(__FieldTag::__rendered_content) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for rendered_content",
));
}
result.rendered_content = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__sdk_blob => {
if !fields.insert(__FieldTag::__sdk_blob) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for sdk_blob",
));
}
struct __With(std::option::Option<::bytes::Bytes>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<serde_with::base64::Base64> >::deserialize(deserializer).map(__With)
}
}
result.sdk_blob = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "grounded-generation-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::generate_grounded_content_response::candidate::grounding_metadata::GroundingSupport
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__claim_text,
__support_chunk_indices,
__support_score,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for GroundingSupport")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"claimText" => Ok(__FieldTag::__claim_text),
"claim_text" => Ok(__FieldTag::__claim_text),
"supportChunkIndices" => Ok(__FieldTag::__support_chunk_indices),
"support_chunk_indices" => Ok(__FieldTag::__support_chunk_indices),
"supportScore" => Ok(__FieldTag::__support_score),
"support_score" => Ok(__FieldTag::__support_score),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::generate_grounded_content_response::candidate::grounding_metadata::GroundingSupport;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GroundingSupport")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__claim_text => {
if !fields.insert(__FieldTag::__claim_text) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for claim_text",
));
}
result.claim_text = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__support_chunk_indices => {
if !fields.insert(__FieldTag::__support_chunk_indices) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for support_chunk_indices",
));
}
struct __With(std::option::Option<std::vec::Vec<i32>>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::<
std::option::Option<std::vec::Vec<wkt::internal::I32>>,
>::deserialize(deserializer)
.map(__With)
}
}
result.support_chunk_indices =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__support_score => {
if !fields.insert(__FieldTag::__support_score) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for support_score",
));
}
struct __With(std::option::Option<f32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F32> >::deserialize(deserializer).map(__With)
}
}
result.support_score = map.next_value::<__With>()?.0;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "grounded-generation-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::generate_grounded_content_response::candidate::grounding_metadata::ImageMetadata
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__image,
__thumbnail,
__source,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ImageMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"image" => Ok(__FieldTag::__image),
"thumbnail" => Ok(__FieldTag::__thumbnail),
"source" => Ok(__FieldTag::__source),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::generate_grounded_content_response::candidate::grounding_metadata::ImageMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ImageMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__image => {
if !fields.insert(__FieldTag::__image) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for image",
));
}
result.image = map.next_value::<std::option::Option<crate::model::generate_grounded_content_response::candidate::grounding_metadata::image_metadata::Image>>()?
;
}
__FieldTag::__thumbnail => {
if !fields.insert(__FieldTag::__thumbnail) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for thumbnail",
));
}
result.thumbnail = map.next_value::<std::option::Option<crate::model::generate_grounded_content_response::candidate::grounding_metadata::image_metadata::Image>>()?
;
}
__FieldTag::__source => {
if !fields.insert(__FieldTag::__source) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for source",
));
}
result.source = map.next_value::<std::option::Option<crate::model::generate_grounded_content_response::candidate::grounding_metadata::image_metadata::WebsiteInfo>>()?
;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "grounded-generation-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::generate_grounded_content_response::candidate::grounding_metadata::image_metadata::WebsiteInfo {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__uri,
__title,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for WebsiteInfo")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"uri" => Ok(__FieldTag::__uri),
"title" => Ok(__FieldTag::__title),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::generate_grounded_content_response::candidate::grounding_metadata::image_metadata::WebsiteInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct WebsiteInfo")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
use std::option::Option::Some;
#[allow(unused_imports)]
use serde::de::Error;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__uri => {
if !fields.insert(__FieldTag::__uri) {
return std::result::Result::Err(A::Error::duplicate_field("multiple values for uri"));
}
result.uri = map.next_value::<std::option::Option<std::string::String>>()?.unwrap_or_default();
},
__FieldTag::__title => {
if !fields.insert(__FieldTag::__title) {
return std::result::Result::Err(A::Error::duplicate_field("multiple values for title"));
}
result.title = map.next_value::<std::option::Option<std::string::String>>()?.unwrap_or_default();
},
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
},
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "grounded-generation-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::generate_grounded_content_response::candidate::grounding_metadata::image_metadata::Image {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__uri,
__width,
__height,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Image")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"uri" => Ok(__FieldTag::__uri),
"width" => Ok(__FieldTag::__width),
"height" => Ok(__FieldTag::__height),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::generate_grounded_content_response::candidate::grounding_metadata::image_metadata::Image;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Image")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
use std::option::Option::Some;
#[allow(unused_imports)]
use serde::de::Error;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__uri => {
if !fields.insert(__FieldTag::__uri) {
return std::result::Result::Err(A::Error::duplicate_field("multiple values for uri"));
}
result.uri = map.next_value::<std::option::Option<std::string::String>>()?.unwrap_or_default();
},
__FieldTag::__width => {
if !fields.insert(__FieldTag::__width) {
return std::result::Result::Err(A::Error::duplicate_field("multiple values for width"));
}
struct __With( std::option::Option<i32> );
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.width = map.next_value::< __With >()?.0.unwrap_or_default();
},
__FieldTag::__height => {
if !fields.insert(__FieldTag::__height) {
return std::result::Result::Err(A::Error::duplicate_field("multiple values for height"));
}
struct __With( std::option::Option<i32> );
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.height = map.next_value::< __With >()?.0.unwrap_or_default();
},
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
},
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "grounded-generation-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::CheckGroundingSpec {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__citation_threshold,
__enable_claim_level_score,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for CheckGroundingSpec")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"citationThreshold" => Ok(__FieldTag::__citation_threshold),
"citation_threshold" => Ok(__FieldTag::__citation_threshold),
"enableClaimLevelScore" => Ok(__FieldTag::__enable_claim_level_score),
"enable_claim_level_score" => {
Ok(__FieldTag::__enable_claim_level_score)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CheckGroundingSpec;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CheckGroundingSpec")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__citation_threshold => {
if !fields.insert(__FieldTag::__citation_threshold) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for citation_threshold",
));
}
struct __With(std::option::Option<f64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F64> >::deserialize(deserializer).map(__With)
}
}
result.citation_threshold = map.next_value::<__With>()?.0;
}
__FieldTag::__enable_claim_level_score => {
if !fields.insert(__FieldTag::__enable_claim_level_score) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for enable_claim_level_score",
));
}
result.enable_claim_level_score =
map.next_value::<std::option::Option<bool>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "grounded-generation-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::CheckGroundingRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__grounding_config,
__answer_candidate,
__facts,
__grounding_spec,
__user_labels,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for CheckGroundingRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"groundingConfig" => Ok(__FieldTag::__grounding_config),
"grounding_config" => Ok(__FieldTag::__grounding_config),
"answerCandidate" => Ok(__FieldTag::__answer_candidate),
"answer_candidate" => Ok(__FieldTag::__answer_candidate),
"facts" => Ok(__FieldTag::__facts),
"groundingSpec" => Ok(__FieldTag::__grounding_spec),
"grounding_spec" => Ok(__FieldTag::__grounding_spec),
"userLabels" => Ok(__FieldTag::__user_labels),
"user_labels" => Ok(__FieldTag::__user_labels),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CheckGroundingRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CheckGroundingRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__grounding_config => {
if !fields.insert(__FieldTag::__grounding_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for grounding_config",
));
}
result.grounding_config = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__answer_candidate => {
if !fields.insert(__FieldTag::__answer_candidate) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for answer_candidate",
));
}
result.answer_candidate = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__facts => {
if !fields.insert(__FieldTag::__facts) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for facts",
));
}
result.facts = map.next_value::<std::option::Option<std::vec::Vec<crate::model::GroundingFact>>>()?.unwrap_or_default();
}
__FieldTag::__grounding_spec => {
if !fields.insert(__FieldTag::__grounding_spec) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for grounding_spec",
));
}
result.grounding_spec = map.next_value::<std::option::Option<crate::model::CheckGroundingSpec>>()?
;
}
__FieldTag::__user_labels => {
if !fields.insert(__FieldTag::__user_labels) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for user_labels",
));
}
result.user_labels = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
std::string::String,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "grounded-generation-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::CheckGroundingResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__support_score,
__cited_chunks,
__cited_facts,
__claims,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for CheckGroundingResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"supportScore" => Ok(__FieldTag::__support_score),
"support_score" => Ok(__FieldTag::__support_score),
"citedChunks" => Ok(__FieldTag::__cited_chunks),
"cited_chunks" => Ok(__FieldTag::__cited_chunks),
"citedFacts" => Ok(__FieldTag::__cited_facts),
"cited_facts" => Ok(__FieldTag::__cited_facts),
"claims" => Ok(__FieldTag::__claims),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CheckGroundingResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CheckGroundingResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__support_score => {
if !fields.insert(__FieldTag::__support_score) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for support_score",
));
}
struct __With(std::option::Option<f32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F32> >::deserialize(deserializer).map(__With)
}
}
result.support_score = map.next_value::<__With>()?.0;
}
__FieldTag::__cited_chunks => {
if !fields.insert(__FieldTag::__cited_chunks) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cited_chunks",
));
}
result.cited_chunks = map.next_value::<std::option::Option<std::vec::Vec<crate::model::FactChunk>>>()?.unwrap_or_default();
}
__FieldTag::__cited_facts => {
if !fields.insert(__FieldTag::__cited_facts) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cited_facts",
));
}
result.cited_facts = map.next_value::<std::option::Option<std::vec::Vec<crate::model::check_grounding_response::CheckGroundingFactChunk>>>()?.unwrap_or_default();
}
__FieldTag::__claims => {
if !fields.insert(__FieldTag::__claims) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for claims",
));
}
result.claims = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::check_grounding_response::Claim>,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "grounded-generation-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::check_grounding_response::CheckGroundingFactChunk {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__chunk_text,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for CheckGroundingFactChunk")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"chunkText" => Ok(__FieldTag::__chunk_text),
"chunk_text" => Ok(__FieldTag::__chunk_text),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::check_grounding_response::CheckGroundingFactChunk;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CheckGroundingFactChunk")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__chunk_text => {
if !fields.insert(__FieldTag::__chunk_text) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for chunk_text",
));
}
result.chunk_text = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "grounded-generation-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::check_grounding_response::Claim {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__start_pos,
__end_pos,
__claim_text,
__citation_indices,
__grounding_check_required,
__score,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Claim")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"startPos" => Ok(__FieldTag::__start_pos),
"start_pos" => Ok(__FieldTag::__start_pos),
"endPos" => Ok(__FieldTag::__end_pos),
"end_pos" => Ok(__FieldTag::__end_pos),
"claimText" => Ok(__FieldTag::__claim_text),
"claim_text" => Ok(__FieldTag::__claim_text),
"citationIndices" => Ok(__FieldTag::__citation_indices),
"citation_indices" => Ok(__FieldTag::__citation_indices),
"groundingCheckRequired" => Ok(__FieldTag::__grounding_check_required),
"grounding_check_required" => {
Ok(__FieldTag::__grounding_check_required)
}
"score" => Ok(__FieldTag::__score),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::check_grounding_response::Claim;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Claim")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__start_pos => {
if !fields.insert(__FieldTag::__start_pos) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for start_pos",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.start_pos = map.next_value::<__With>()?.0;
}
__FieldTag::__end_pos => {
if !fields.insert(__FieldTag::__end_pos) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for end_pos",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.end_pos = map.next_value::<__With>()?.0;
}
__FieldTag::__claim_text => {
if !fields.insert(__FieldTag::__claim_text) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for claim_text",
));
}
result.claim_text = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__citation_indices => {
if !fields.insert(__FieldTag::__citation_indices) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for citation_indices",
));
}
struct __With(std::option::Option<std::vec::Vec<i32>>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::<
std::option::Option<std::vec::Vec<wkt::internal::I32>>,
>::deserialize(deserializer)
.map(__With)
}
}
result.citation_indices =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__grounding_check_required => {
if !fields.insert(__FieldTag::__grounding_check_required) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for grounding_check_required",
));
}
result.grounding_check_required =
map.next_value::<std::option::Option<bool>>()?;
}
__FieldTag::__score => {
if !fields.insert(__FieldTag::__score) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for score",
));
}
struct __With(std::option::Option<f64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F64> >::deserialize(deserializer).map(__With)
}
}
result.score = map.next_value::<__With>()?.0;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "grounded-generation-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::GroundingFact {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__fact_text,
__attributes,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for GroundingFact")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"factText" => Ok(__FieldTag::__fact_text),
"fact_text" => Ok(__FieldTag::__fact_text),
"attributes" => Ok(__FieldTag::__attributes),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::GroundingFact;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GroundingFact")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__fact_text => {
if !fields.insert(__FieldTag::__fact_text) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for fact_text",
));
}
result.fact_text = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__attributes => {
if !fields.insert(__FieldTag::__attributes) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for attributes",
));
}
result.attributes = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
std::string::String,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "grounded-generation-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::FactChunk {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__chunk_text,
__source,
__index,
__source_metadata,
__uri,
__title,
__domain,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for FactChunk")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"chunkText" => Ok(__FieldTag::__chunk_text),
"chunk_text" => Ok(__FieldTag::__chunk_text),
"source" => Ok(__FieldTag::__source),
"index" => Ok(__FieldTag::__index),
"sourceMetadata" => Ok(__FieldTag::__source_metadata),
"source_metadata" => Ok(__FieldTag::__source_metadata),
"uri" => Ok(__FieldTag::__uri),
"title" => Ok(__FieldTag::__title),
"domain" => Ok(__FieldTag::__domain),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::FactChunk;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct FactChunk")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__chunk_text => {
if !fields.insert(__FieldTag::__chunk_text) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for chunk_text",
));
}
result.chunk_text = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__source => {
if !fields.insert(__FieldTag::__source) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for source",
));
}
result.source = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__index => {
if !fields.insert(__FieldTag::__index) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for index",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.index = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__source_metadata => {
if !fields.insert(__FieldTag::__source_metadata) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for source_metadata",
));
}
result.source_metadata = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
std::string::String,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::__uri => {
if !fields.insert(__FieldTag::__uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for uri",
));
}
result.uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__title => {
if !fields.insert(__FieldTag::__title) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for title",
));
}
result.title = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__domain => {
if !fields.insert(__FieldTag::__domain) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for domain",
));
}
result.domain = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "identity-mapping-store-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::IdentityMappingStore {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
__kms_key_name,
__cmek_config,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for IdentityMappingStore")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
"kmsKeyName" => Ok(__FieldTag::__kms_key_name),
"kms_key_name" => Ok(__FieldTag::__kms_key_name),
"cmekConfig" => Ok(__FieldTag::__cmek_config),
"cmek_config" => Ok(__FieldTag::__cmek_config),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::IdentityMappingStore;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct IdentityMappingStore")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__kms_key_name => {
if !fields.insert(__FieldTag::__kms_key_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for kms_key_name",
));
}
result.kms_key_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__cmek_config => {
if !fields.insert(__FieldTag::__cmek_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cmek_config",
));
}
result.cmek_config =
map.next_value::<std::option::Option<crate::model::CmekConfig>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "identity-mapping-store-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::IdentityMappingEntry {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__user_id,
__group_id,
__external_identity,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for IdentityMappingEntry")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"userId" => Ok(__FieldTag::__user_id),
"user_id" => Ok(__FieldTag::__user_id),
"groupId" => Ok(__FieldTag::__group_id),
"group_id" => Ok(__FieldTag::__group_id),
"externalIdentity" => Ok(__FieldTag::__external_identity),
"external_identity" => Ok(__FieldTag::__external_identity),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::IdentityMappingEntry;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct IdentityMappingEntry")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__user_id => {
if !fields.insert(__FieldTag::__user_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for user_id",
));
}
if result.identity_provider_id.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `identity_provider_id`, a oneof with full ID .google.cloud.discoveryengine.v1.IdentityMappingEntry.user_id, latest field was userId",
));
}
result.identity_provider_id = std::option::Option::Some(
crate::model::identity_mapping_entry::IdentityProviderId::UserId(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__group_id => {
if !fields.insert(__FieldTag::__group_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for group_id",
));
}
if result.identity_provider_id.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `identity_provider_id`, a oneof with full ID .google.cloud.discoveryengine.v1.IdentityMappingEntry.group_id, latest field was groupId",
));
}
result.identity_provider_id = std::option::Option::Some(
crate::model::identity_mapping_entry::IdentityProviderId::GroupId(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__external_identity => {
if !fields.insert(__FieldTag::__external_identity) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for external_identity",
));
}
result.external_identity = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "identity-mapping-store-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::CreateIdentityMappingStoreRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__cmek_config_name,
__disable_cmek,
__parent,
__identity_mapping_store_id,
__identity_mapping_store,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for CreateIdentityMappingStoreRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"cmekConfigName" => Ok(__FieldTag::__cmek_config_name),
"cmek_config_name" => Ok(__FieldTag::__cmek_config_name),
"disableCmek" => Ok(__FieldTag::__disable_cmek),
"disable_cmek" => Ok(__FieldTag::__disable_cmek),
"parent" => Ok(__FieldTag::__parent),
"identityMappingStoreId" => Ok(__FieldTag::__identity_mapping_store_id),
"identity_mapping_store_id" => {
Ok(__FieldTag::__identity_mapping_store_id)
}
"identityMappingStore" => Ok(__FieldTag::__identity_mapping_store),
"identity_mapping_store" => Ok(__FieldTag::__identity_mapping_store),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CreateIdentityMappingStoreRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CreateIdentityMappingStoreRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__cmek_config_name => {
if !fields.insert(__FieldTag::__cmek_config_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cmek_config_name",
));
}
if result.cmek_options.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `cmek_options`, a oneof with full ID .google.cloud.discoveryengine.v1.CreateIdentityMappingStoreRequest.cmek_config_name, latest field was cmekConfigName",
));
}
result.cmek_options = std::option::Option::Some(
crate::model::create_identity_mapping_store_request::CmekOptions::CmekConfigName(
map.next_value::<std::option::Option<std::string::String>>()?.unwrap_or_default()
),
);
}
__FieldTag::__disable_cmek => {
if !fields.insert(__FieldTag::__disable_cmek) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for disable_cmek",
));
}
if result.cmek_options.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `cmek_options`, a oneof with full ID .google.cloud.discoveryengine.v1.CreateIdentityMappingStoreRequest.disable_cmek, latest field was disableCmek",
));
}
result.cmek_options = std::option::Option::Some(
crate::model::create_identity_mapping_store_request::CmekOptions::DisableCmek(
map.next_value::<std::option::Option<bool>>()?.unwrap_or_default()
),
);
}
__FieldTag::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__identity_mapping_store_id => {
if !fields.insert(__FieldTag::__identity_mapping_store_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for identity_mapping_store_id",
));
}
result.identity_mapping_store_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__identity_mapping_store => {
if !fields.insert(__FieldTag::__identity_mapping_store) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for identity_mapping_store",
));
}
result.identity_mapping_store = map.next_value::<std::option::Option<crate::model::IdentityMappingStore>>()?
;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "identity-mapping-store-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::GetIdentityMappingStoreRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for GetIdentityMappingStoreRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::GetIdentityMappingStoreRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GetIdentityMappingStoreRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "identity-mapping-store-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::DeleteIdentityMappingStoreRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DeleteIdentityMappingStoreRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DeleteIdentityMappingStoreRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DeleteIdentityMappingStoreRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "identity-mapping-store-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ImportIdentityMappingsRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__inline_source,
__identity_mapping_store,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ImportIdentityMappingsRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"inlineSource" => Ok(__FieldTag::__inline_source),
"inline_source" => Ok(__FieldTag::__inline_source),
"identityMappingStore" => Ok(__FieldTag::__identity_mapping_store),
"identity_mapping_store" => Ok(__FieldTag::__identity_mapping_store),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ImportIdentityMappingsRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ImportIdentityMappingsRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__inline_source => {
if !fields.insert(__FieldTag::__inline_source) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for inline_source",
));
}
if result.source.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `source`, a oneof with full ID .google.cloud.discoveryengine.v1.ImportIdentityMappingsRequest.inline_source, latest field was inlineSource",
));
}
result.source = std::option::Option::Some(
crate::model::import_identity_mappings_request::Source::InlineSource(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::import_identity_mappings_request::InlineSource>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__identity_mapping_store => {
if !fields.insert(__FieldTag::__identity_mapping_store) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for identity_mapping_store",
));
}
result.identity_mapping_store = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "identity-mapping-store-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::import_identity_mappings_request::InlineSource {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__identity_mapping_entries,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for InlineSource")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"identityMappingEntries" => Ok(__FieldTag::__identity_mapping_entries),
"identity_mapping_entries" => {
Ok(__FieldTag::__identity_mapping_entries)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::import_identity_mappings_request::InlineSource;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct InlineSource")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__identity_mapping_entries => {
if !fields.insert(__FieldTag::__identity_mapping_entries) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for identity_mapping_entries",
));
}
result.identity_mapping_entries = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::IdentityMappingEntry>,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "identity-mapping-store-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ImportIdentityMappingsResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__error_samples,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ImportIdentityMappingsResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"errorSamples" => Ok(__FieldTag::__error_samples),
"error_samples" => Ok(__FieldTag::__error_samples),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ImportIdentityMappingsResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ImportIdentityMappingsResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__error_samples => {
if !fields.insert(__FieldTag::__error_samples) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for error_samples",
));
}
result.error_samples =
map.next_value::<std::option::Option<
std::vec::Vec<google_cloud_rpc::model::Status>,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "identity-mapping-store-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::PurgeIdentityMappingsRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__inline_source,
__identity_mapping_store,
__filter,
__force,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for PurgeIdentityMappingsRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"inlineSource" => Ok(__FieldTag::__inline_source),
"inline_source" => Ok(__FieldTag::__inline_source),
"identityMappingStore" => Ok(__FieldTag::__identity_mapping_store),
"identity_mapping_store" => Ok(__FieldTag::__identity_mapping_store),
"filter" => Ok(__FieldTag::__filter),
"force" => Ok(__FieldTag::__force),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::PurgeIdentityMappingsRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct PurgeIdentityMappingsRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__inline_source => {
if !fields.insert(__FieldTag::__inline_source) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for inline_source",
));
}
if result.source.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `source`, a oneof with full ID .google.cloud.discoveryengine.v1.PurgeIdentityMappingsRequest.inline_source, latest field was inlineSource",
));
}
result.source = std::option::Option::Some(
crate::model::purge_identity_mappings_request::Source::InlineSource(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::purge_identity_mappings_request::InlineSource>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__identity_mapping_store => {
if !fields.insert(__FieldTag::__identity_mapping_store) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for identity_mapping_store",
));
}
result.identity_mapping_store = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__filter => {
if !fields.insert(__FieldTag::__filter) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for filter",
));
}
result.filter = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__force => {
if !fields.insert(__FieldTag::__force) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for force",
));
}
result.force = map.next_value::<std::option::Option<bool>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "identity-mapping-store-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::purge_identity_mappings_request::InlineSource {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__identity_mapping_entries,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for InlineSource")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"identityMappingEntries" => Ok(__FieldTag::__identity_mapping_entries),
"identity_mapping_entries" => {
Ok(__FieldTag::__identity_mapping_entries)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::purge_identity_mappings_request::InlineSource;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct InlineSource")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__identity_mapping_entries => {
if !fields.insert(__FieldTag::__identity_mapping_entries) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for identity_mapping_entries",
));
}
result.identity_mapping_entries = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::IdentityMappingEntry>,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "identity-mapping-store-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ListIdentityMappingsRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__identity_mapping_store,
__page_size,
__page_token,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ListIdentityMappingsRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"identityMappingStore" => Ok(__FieldTag::__identity_mapping_store),
"identity_mapping_store" => Ok(__FieldTag::__identity_mapping_store),
"pageSize" => Ok(__FieldTag::__page_size),
"page_size" => Ok(__FieldTag::__page_size),
"pageToken" => Ok(__FieldTag::__page_token),
"page_token" => Ok(__FieldTag::__page_token),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListIdentityMappingsRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListIdentityMappingsRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__identity_mapping_store => {
if !fields.insert(__FieldTag::__identity_mapping_store) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for identity_mapping_store",
));
}
result.identity_mapping_store = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__page_size => {
if !fields.insert(__FieldTag::__page_size) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_size",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.page_size = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__page_token => {
if !fields.insert(__FieldTag::__page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_token",
));
}
result.page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "identity-mapping-store-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ListIdentityMappingsResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__identity_mapping_entries,
__next_page_token,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ListIdentityMappingsResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"identityMappingEntries" => Ok(__FieldTag::__identity_mapping_entries),
"identity_mapping_entries" => {
Ok(__FieldTag::__identity_mapping_entries)
}
"nextPageToken" => Ok(__FieldTag::__next_page_token),
"next_page_token" => Ok(__FieldTag::__next_page_token),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListIdentityMappingsResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListIdentityMappingsResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__identity_mapping_entries => {
if !fields.insert(__FieldTag::__identity_mapping_entries) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for identity_mapping_entries",
));
}
result.identity_mapping_entries = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::IdentityMappingEntry>,
>>()?
.unwrap_or_default();
}
__FieldTag::__next_page_token => {
if !fields.insert(__FieldTag::__next_page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for next_page_token",
));
}
result.next_page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "identity-mapping-store-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ListIdentityMappingStoresRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__parent,
__page_size,
__page_token,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ListIdentityMappingStoresRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"parent" => Ok(__FieldTag::__parent),
"pageSize" => Ok(__FieldTag::__page_size),
"page_size" => Ok(__FieldTag::__page_size),
"pageToken" => Ok(__FieldTag::__page_token),
"page_token" => Ok(__FieldTag::__page_token),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListIdentityMappingStoresRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListIdentityMappingStoresRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__page_size => {
if !fields.insert(__FieldTag::__page_size) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_size",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.page_size = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__page_token => {
if !fields.insert(__FieldTag::__page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_token",
));
}
result.page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "identity-mapping-store-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ListIdentityMappingStoresResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__identity_mapping_stores,
__next_page_token,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ListIdentityMappingStoresResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"identityMappingStores" => Ok(__FieldTag::__identity_mapping_stores),
"identity_mapping_stores" => Ok(__FieldTag::__identity_mapping_stores),
"nextPageToken" => Ok(__FieldTag::__next_page_token),
"next_page_token" => Ok(__FieldTag::__next_page_token),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListIdentityMappingStoresResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListIdentityMappingStoresResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__identity_mapping_stores => {
if !fields.insert(__FieldTag::__identity_mapping_stores) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for identity_mapping_stores",
));
}
result.identity_mapping_stores = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::IdentityMappingStore>,
>>()?
.unwrap_or_default();
}
__FieldTag::__next_page_token => {
if !fields.insert(__FieldTag::__next_page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for next_page_token",
));
}
result.next_page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "identity-mapping-store-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::IdentityMappingEntryOperationMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__success_count,
__failure_count,
__total_count,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter
.write_str("a field name for IdentityMappingEntryOperationMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"successCount" => Ok(__FieldTag::__success_count),
"success_count" => Ok(__FieldTag::__success_count),
"failureCount" => Ok(__FieldTag::__failure_count),
"failure_count" => Ok(__FieldTag::__failure_count),
"totalCount" => Ok(__FieldTag::__total_count),
"total_count" => Ok(__FieldTag::__total_count),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::IdentityMappingEntryOperationMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct IdentityMappingEntryOperationMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__success_count => {
if !fields.insert(__FieldTag::__success_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for success_count",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.success_count =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__failure_count => {
if !fields.insert(__FieldTag::__failure_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for failure_count",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.failure_count =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__total_count => {
if !fields.insert(__FieldTag::__total_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for total_count",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.total_count = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "identity-mapping-store-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::DeleteIdentityMappingStoreMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__create_time,
__update_time,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DeleteIdentityMappingStoreMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"updateTime" => Ok(__FieldTag::__update_time),
"update_time" => Ok(__FieldTag::__update_time),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DeleteIdentityMappingStoreMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DeleteIdentityMappingStoreMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__update_time => {
if !fields.insert(__FieldTag::__update_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_time",
));
}
result.update_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "completion-service",
feature = "document-service",
feature = "user-event-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::GcsSource {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__input_uris,
__data_schema,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for GcsSource")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"inputUris" => Ok(__FieldTag::__input_uris),
"input_uris" => Ok(__FieldTag::__input_uris),
"dataSchema" => Ok(__FieldTag::__data_schema),
"data_schema" => Ok(__FieldTag::__data_schema),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::GcsSource;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GcsSource")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__input_uris => {
if !fields.insert(__FieldTag::__input_uris) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for input_uris",
));
}
result.input_uris = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__data_schema => {
if !fields.insert(__FieldTag::__data_schema) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for data_schema",
));
}
result.data_schema = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "completion-service",
feature = "document-service",
feature = "user-event-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::BigQuerySource {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__partition_date,
__project_id,
__dataset_id,
__table_id,
__gcs_staging_dir,
__data_schema,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for BigQuerySource")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"partitionDate" => Ok(__FieldTag::__partition_date),
"partition_date" => Ok(__FieldTag::__partition_date),
"projectId" => Ok(__FieldTag::__project_id),
"project_id" => Ok(__FieldTag::__project_id),
"datasetId" => Ok(__FieldTag::__dataset_id),
"dataset_id" => Ok(__FieldTag::__dataset_id),
"tableId" => Ok(__FieldTag::__table_id),
"table_id" => Ok(__FieldTag::__table_id),
"gcsStagingDir" => Ok(__FieldTag::__gcs_staging_dir),
"gcs_staging_dir" => Ok(__FieldTag::__gcs_staging_dir),
"dataSchema" => Ok(__FieldTag::__data_schema),
"data_schema" => Ok(__FieldTag::__data_schema),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::BigQuerySource;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BigQuerySource")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__partition_date => {
if !fields.insert(__FieldTag::__partition_date) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for partition_date",
));
}
if result.partition.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `partition`, a oneof with full ID .google.cloud.discoveryengine.v1.BigQuerySource.partition_date, latest field was partitionDate",
));
}
result.partition = std::option::Option::Some(
crate::model::big_query_source::Partition::PartitionDate(
map.next_value::<std::option::Option<
std::boxed::Box<google_cloud_type::model::Date>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__project_id => {
if !fields.insert(__FieldTag::__project_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for project_id",
));
}
result.project_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__dataset_id => {
if !fields.insert(__FieldTag::__dataset_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for dataset_id",
));
}
result.dataset_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__table_id => {
if !fields.insert(__FieldTag::__table_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for table_id",
));
}
result.table_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__gcs_staging_dir => {
if !fields.insert(__FieldTag::__gcs_staging_dir) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for gcs_staging_dir",
));
}
result.gcs_staging_dir = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__data_schema => {
if !fields.insert(__FieldTag::__data_schema) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for data_schema",
));
}
result.data_schema = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "document-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::SpannerSource {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__project_id,
__instance_id,
__database_id,
__table_id,
__enable_data_boost,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SpannerSource")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"projectId" => Ok(__FieldTag::__project_id),
"project_id" => Ok(__FieldTag::__project_id),
"instanceId" => Ok(__FieldTag::__instance_id),
"instance_id" => Ok(__FieldTag::__instance_id),
"databaseId" => Ok(__FieldTag::__database_id),
"database_id" => Ok(__FieldTag::__database_id),
"tableId" => Ok(__FieldTag::__table_id),
"table_id" => Ok(__FieldTag::__table_id),
"enableDataBoost" => Ok(__FieldTag::__enable_data_boost),
"enable_data_boost" => Ok(__FieldTag::__enable_data_boost),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::SpannerSource;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SpannerSource")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__project_id => {
if !fields.insert(__FieldTag::__project_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for project_id",
));
}
result.project_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__instance_id => {
if !fields.insert(__FieldTag::__instance_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for instance_id",
));
}
result.instance_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__database_id => {
if !fields.insert(__FieldTag::__database_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for database_id",
));
}
result.database_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__table_id => {
if !fields.insert(__FieldTag::__table_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for table_id",
));
}
result.table_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__enable_data_boost => {
if !fields.insert(__FieldTag::__enable_data_boost) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for enable_data_boost",
));
}
result.enable_data_boost = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "document-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::BigtableOptions {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__key_field_name,
__families,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for BigtableOptions")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"keyFieldName" => Ok(__FieldTag::__key_field_name),
"key_field_name" => Ok(__FieldTag::__key_field_name),
"families" => Ok(__FieldTag::__families),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::BigtableOptions;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BigtableOptions")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__key_field_name => {
if !fields.insert(__FieldTag::__key_field_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for key_field_name",
));
}
result.key_field_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__families => {
if !fields.insert(__FieldTag::__families) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for families",
));
}
result.families = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
crate::model::bigtable_options::BigtableColumnFamily,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "document-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::bigtable_options::BigtableColumnFamily {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__field_name,
__encoding,
__type,
__columns,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for BigtableColumnFamily")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"fieldName" => Ok(__FieldTag::__field_name),
"field_name" => Ok(__FieldTag::__field_name),
"encoding" => Ok(__FieldTag::__encoding),
"type" => Ok(__FieldTag::__type),
"columns" => Ok(__FieldTag::__columns),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::bigtable_options::BigtableColumnFamily;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BigtableColumnFamily")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__field_name => {
if !fields.insert(__FieldTag::__field_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for field_name",
));
}
result.field_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__encoding => {
if !fields.insert(__FieldTag::__encoding) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for encoding",
));
}
result.encoding = map.next_value::<std::option::Option<crate::model::bigtable_options::Encoding>>()?.unwrap_or_default();
}
__FieldTag::__type => {
if !fields.insert(__FieldTag::__type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for type",
));
}
result.r#type = map.next_value::<std::option::Option<crate::model::bigtable_options::Type>>()?.unwrap_or_default();
}
__FieldTag::__columns => {
if !fields.insert(__FieldTag::__columns) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for columns",
));
}
result.columns = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::bigtable_options::BigtableColumn>,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "document-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::bigtable_options::BigtableColumn {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__qualifier,
__field_name,
__encoding,
__type,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for BigtableColumn")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"qualifier" => Ok(__FieldTag::__qualifier),
"fieldName" => Ok(__FieldTag::__field_name),
"field_name" => Ok(__FieldTag::__field_name),
"encoding" => Ok(__FieldTag::__encoding),
"type" => Ok(__FieldTag::__type),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::bigtable_options::BigtableColumn;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BigtableColumn")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__qualifier => {
if !fields.insert(__FieldTag::__qualifier) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for qualifier",
));
}
struct __With(std::option::Option<::bytes::Bytes>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<serde_with::base64::Base64> >::deserialize(deserializer).map(__With)
}
}
result.qualifier = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__field_name => {
if !fields.insert(__FieldTag::__field_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for field_name",
));
}
result.field_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__encoding => {
if !fields.insert(__FieldTag::__encoding) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for encoding",
));
}
result.encoding = map.next_value::<std::option::Option<crate::model::bigtable_options::Encoding>>()?.unwrap_or_default();
}
__FieldTag::__type => {
if !fields.insert(__FieldTag::__type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for type",
));
}
result.r#type = map.next_value::<std::option::Option<crate::model::bigtable_options::Type>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "document-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::BigtableSource {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__project_id,
__instance_id,
__table_id,
__bigtable_options,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for BigtableSource")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"projectId" => Ok(__FieldTag::__project_id),
"project_id" => Ok(__FieldTag::__project_id),
"instanceId" => Ok(__FieldTag::__instance_id),
"instance_id" => Ok(__FieldTag::__instance_id),
"tableId" => Ok(__FieldTag::__table_id),
"table_id" => Ok(__FieldTag::__table_id),
"bigtableOptions" => Ok(__FieldTag::__bigtable_options),
"bigtable_options" => Ok(__FieldTag::__bigtable_options),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::BigtableSource;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BigtableSource")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__project_id => {
if !fields.insert(__FieldTag::__project_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for project_id",
));
}
result.project_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__instance_id => {
if !fields.insert(__FieldTag::__instance_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for instance_id",
));
}
result.instance_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__table_id => {
if !fields.insert(__FieldTag::__table_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for table_id",
));
}
result.table_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__bigtable_options => {
if !fields.insert(__FieldTag::__bigtable_options) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for bigtable_options",
));
}
result.bigtable_options = map
.next_value::<std::option::Option<crate::model::BigtableOptions>>(
)?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "document-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::FhirStoreSource {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__fhir_store,
__gcs_staging_dir,
__resource_types,
__update_from_latest_predefined_schema,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for FhirStoreSource")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"fhirStore" => Ok(__FieldTag::__fhir_store),
"fhir_store" => Ok(__FieldTag::__fhir_store),
"gcsStagingDir" => Ok(__FieldTag::__gcs_staging_dir),
"gcs_staging_dir" => Ok(__FieldTag::__gcs_staging_dir),
"resourceTypes" => Ok(__FieldTag::__resource_types),
"resource_types" => Ok(__FieldTag::__resource_types),
"updateFromLatestPredefinedSchema" => {
Ok(__FieldTag::__update_from_latest_predefined_schema)
}
"update_from_latest_predefined_schema" => {
Ok(__FieldTag::__update_from_latest_predefined_schema)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::FhirStoreSource;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct FhirStoreSource")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__fhir_store => {
if !fields.insert(__FieldTag::__fhir_store) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for fhir_store",
));
}
result.fhir_store = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__gcs_staging_dir => {
if !fields.insert(__FieldTag::__gcs_staging_dir) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for gcs_staging_dir",
));
}
result.gcs_staging_dir = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__resource_types => {
if !fields.insert(__FieldTag::__resource_types) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for resource_types",
));
}
result.resource_types = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__update_from_latest_predefined_schema => {
if !fields.insert(__FieldTag::__update_from_latest_predefined_schema) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_from_latest_predefined_schema",
));
}
result.update_from_latest_predefined_schema = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "document-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::CloudSqlSource {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__project_id,
__instance_id,
__database_id,
__table_id,
__gcs_staging_dir,
__offload,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for CloudSqlSource")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"projectId" => Ok(__FieldTag::__project_id),
"project_id" => Ok(__FieldTag::__project_id),
"instanceId" => Ok(__FieldTag::__instance_id),
"instance_id" => Ok(__FieldTag::__instance_id),
"databaseId" => Ok(__FieldTag::__database_id),
"database_id" => Ok(__FieldTag::__database_id),
"tableId" => Ok(__FieldTag::__table_id),
"table_id" => Ok(__FieldTag::__table_id),
"gcsStagingDir" => Ok(__FieldTag::__gcs_staging_dir),
"gcs_staging_dir" => Ok(__FieldTag::__gcs_staging_dir),
"offload" => Ok(__FieldTag::__offload),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CloudSqlSource;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CloudSqlSource")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__project_id => {
if !fields.insert(__FieldTag::__project_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for project_id",
));
}
result.project_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__instance_id => {
if !fields.insert(__FieldTag::__instance_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for instance_id",
));
}
result.instance_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__database_id => {
if !fields.insert(__FieldTag::__database_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for database_id",
));
}
result.database_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__table_id => {
if !fields.insert(__FieldTag::__table_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for table_id",
));
}
result.table_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__gcs_staging_dir => {
if !fields.insert(__FieldTag::__gcs_staging_dir) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for gcs_staging_dir",
));
}
result.gcs_staging_dir = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__offload => {
if !fields.insert(__FieldTag::__offload) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for offload",
));
}
result.offload = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "document-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::AlloyDbSource {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__project_id,
__location_id,
__cluster_id,
__database_id,
__table_id,
__gcs_staging_dir,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for AlloyDbSource")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"projectId" => Ok(__FieldTag::__project_id),
"project_id" => Ok(__FieldTag::__project_id),
"locationId" => Ok(__FieldTag::__location_id),
"location_id" => Ok(__FieldTag::__location_id),
"clusterId" => Ok(__FieldTag::__cluster_id),
"cluster_id" => Ok(__FieldTag::__cluster_id),
"databaseId" => Ok(__FieldTag::__database_id),
"database_id" => Ok(__FieldTag::__database_id),
"tableId" => Ok(__FieldTag::__table_id),
"table_id" => Ok(__FieldTag::__table_id),
"gcsStagingDir" => Ok(__FieldTag::__gcs_staging_dir),
"gcs_staging_dir" => Ok(__FieldTag::__gcs_staging_dir),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::AlloyDbSource;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct AlloyDbSource")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__project_id => {
if !fields.insert(__FieldTag::__project_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for project_id",
));
}
result.project_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__location_id => {
if !fields.insert(__FieldTag::__location_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for location_id",
));
}
result.location_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__cluster_id => {
if !fields.insert(__FieldTag::__cluster_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cluster_id",
));
}
result.cluster_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__database_id => {
if !fields.insert(__FieldTag::__database_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for database_id",
));
}
result.database_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__table_id => {
if !fields.insert(__FieldTag::__table_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for table_id",
));
}
result.table_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__gcs_staging_dir => {
if !fields.insert(__FieldTag::__gcs_staging_dir) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for gcs_staging_dir",
));
}
result.gcs_staging_dir = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "document-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::FirestoreSource {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__project_id,
__database_id,
__collection_id,
__gcs_staging_dir,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for FirestoreSource")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"projectId" => Ok(__FieldTag::__project_id),
"project_id" => Ok(__FieldTag::__project_id),
"databaseId" => Ok(__FieldTag::__database_id),
"database_id" => Ok(__FieldTag::__database_id),
"collectionId" => Ok(__FieldTag::__collection_id),
"collection_id" => Ok(__FieldTag::__collection_id),
"gcsStagingDir" => Ok(__FieldTag::__gcs_staging_dir),
"gcs_staging_dir" => Ok(__FieldTag::__gcs_staging_dir),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::FirestoreSource;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct FirestoreSource")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__project_id => {
if !fields.insert(__FieldTag::__project_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for project_id",
));
}
result.project_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__database_id => {
if !fields.insert(__FieldTag::__database_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for database_id",
));
}
result.database_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__collection_id => {
if !fields.insert(__FieldTag::__collection_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for collection_id",
));
}
result.collection_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__gcs_staging_dir => {
if !fields.insert(__FieldTag::__gcs_staging_dir) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for gcs_staging_dir",
));
}
result.gcs_staging_dir = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "completion-service",
feature = "document-service",
feature = "search-tuning-service",
feature = "user-event-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ImportErrorConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__gcs_prefix,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ImportErrorConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"gcsPrefix" => Ok(__FieldTag::__gcs_prefix),
"gcs_prefix" => Ok(__FieldTag::__gcs_prefix),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ImportErrorConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ImportErrorConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__gcs_prefix => {
if !fields.insert(__FieldTag::__gcs_prefix) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for gcs_prefix",
));
}
if result.destination.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `destination`, a oneof with full ID .google.cloud.discoveryengine.v1.ImportErrorConfig.gcs_prefix, latest field was gcsPrefix",
));
}
result.destination = std::option::Option::Some(
crate::model::import_error_config::Destination::GcsPrefix(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "user-event-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ImportUserEventsRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__inline_source,
__gcs_source,
__bigquery_source,
__parent,
__error_config,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ImportUserEventsRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"inlineSource" => Ok(__FieldTag::__inline_source),
"inline_source" => Ok(__FieldTag::__inline_source),
"gcsSource" => Ok(__FieldTag::__gcs_source),
"gcs_source" => Ok(__FieldTag::__gcs_source),
"bigquerySource" => Ok(__FieldTag::__bigquery_source),
"bigquery_source" => Ok(__FieldTag::__bigquery_source),
"parent" => Ok(__FieldTag::__parent),
"errorConfig" => Ok(__FieldTag::__error_config),
"error_config" => Ok(__FieldTag::__error_config),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ImportUserEventsRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ImportUserEventsRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__inline_source => {
if !fields.insert(__FieldTag::__inline_source) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for inline_source",
));
}
if result.source.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `source`, a oneof with full ID .google.cloud.discoveryengine.v1.ImportUserEventsRequest.inline_source, latest field was inlineSource",
));
}
result.source = std::option::Option::Some(
crate::model::import_user_events_request::Source::InlineSource(
map.next_value::<std::option::Option<
std::boxed::Box<
crate::model::import_user_events_request::InlineSource,
>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__gcs_source => {
if !fields.insert(__FieldTag::__gcs_source) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for gcs_source",
));
}
if result.source.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `source`, a oneof with full ID .google.cloud.discoveryengine.v1.ImportUserEventsRequest.gcs_source, latest field was gcsSource",
));
}
result.source = std::option::Option::Some(
crate::model::import_user_events_request::Source::GcsSource(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::GcsSource>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__bigquery_source => {
if !fields.insert(__FieldTag::__bigquery_source) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for bigquery_source",
));
}
if result.source.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `source`, a oneof with full ID .google.cloud.discoveryengine.v1.ImportUserEventsRequest.bigquery_source, latest field was bigquerySource",
));
}
result.source = std::option::Option::Some(
crate::model::import_user_events_request::Source::BigquerySource(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::BigQuerySource>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__error_config => {
if !fields.insert(__FieldTag::__error_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for error_config",
));
}
result.error_config = map
.next_value::<std::option::Option<crate::model::ImportErrorConfig>>(
)?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "user-event-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::import_user_events_request::InlineSource {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__user_events,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for InlineSource")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"userEvents" => Ok(__FieldTag::__user_events),
"user_events" => Ok(__FieldTag::__user_events),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::import_user_events_request::InlineSource;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct InlineSource")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__user_events => {
if !fields.insert(__FieldTag::__user_events) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for user_events",
));
}
result.user_events = map.next_value::<std::option::Option<std::vec::Vec<crate::model::UserEvent>>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "user-event-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ImportUserEventsResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__error_samples,
__error_config,
__joined_events_count,
__unjoined_events_count,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ImportUserEventsResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"errorSamples" => Ok(__FieldTag::__error_samples),
"error_samples" => Ok(__FieldTag::__error_samples),
"errorConfig" => Ok(__FieldTag::__error_config),
"error_config" => Ok(__FieldTag::__error_config),
"joinedEventsCount" => Ok(__FieldTag::__joined_events_count),
"joined_events_count" => Ok(__FieldTag::__joined_events_count),
"unjoinedEventsCount" => Ok(__FieldTag::__unjoined_events_count),
"unjoined_events_count" => Ok(__FieldTag::__unjoined_events_count),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ImportUserEventsResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ImportUserEventsResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__error_samples => {
if !fields.insert(__FieldTag::__error_samples) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for error_samples",
));
}
result.error_samples =
map.next_value::<std::option::Option<
std::vec::Vec<google_cloud_rpc::model::Status>,
>>()?
.unwrap_or_default();
}
__FieldTag::__error_config => {
if !fields.insert(__FieldTag::__error_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for error_config",
));
}
result.error_config = map
.next_value::<std::option::Option<crate::model::ImportErrorConfig>>(
)?;
}
__FieldTag::__joined_events_count => {
if !fields.insert(__FieldTag::__joined_events_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for joined_events_count",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.joined_events_count =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__unjoined_events_count => {
if !fields.insert(__FieldTag::__unjoined_events_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for unjoined_events_count",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.unjoined_events_count =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "user-event-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ImportUserEventsMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__create_time,
__update_time,
__success_count,
__failure_count,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ImportUserEventsMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"updateTime" => Ok(__FieldTag::__update_time),
"update_time" => Ok(__FieldTag::__update_time),
"successCount" => Ok(__FieldTag::__success_count),
"success_count" => Ok(__FieldTag::__success_count),
"failureCount" => Ok(__FieldTag::__failure_count),
"failure_count" => Ok(__FieldTag::__failure_count),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ImportUserEventsMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ImportUserEventsMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__update_time => {
if !fields.insert(__FieldTag::__update_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_time",
));
}
result.update_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__success_count => {
if !fields.insert(__FieldTag::__success_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for success_count",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.success_count =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__failure_count => {
if !fields.insert(__FieldTag::__failure_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for failure_count",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.failure_count =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "document-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ImportDocumentsMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__create_time,
__update_time,
__success_count,
__failure_count,
__total_count,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ImportDocumentsMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"updateTime" => Ok(__FieldTag::__update_time),
"update_time" => Ok(__FieldTag::__update_time),
"successCount" => Ok(__FieldTag::__success_count),
"success_count" => Ok(__FieldTag::__success_count),
"failureCount" => Ok(__FieldTag::__failure_count),
"failure_count" => Ok(__FieldTag::__failure_count),
"totalCount" => Ok(__FieldTag::__total_count),
"total_count" => Ok(__FieldTag::__total_count),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ImportDocumentsMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ImportDocumentsMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__update_time => {
if !fields.insert(__FieldTag::__update_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_time",
));
}
result.update_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__success_count => {
if !fields.insert(__FieldTag::__success_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for success_count",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.success_count =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__failure_count => {
if !fields.insert(__FieldTag::__failure_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for failure_count",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.failure_count =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__total_count => {
if !fields.insert(__FieldTag::__total_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for total_count",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.total_count = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "document-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ImportDocumentsRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__inline_source,
__gcs_source,
__bigquery_source,
__fhir_store_source,
__spanner_source,
__cloud_sql_source,
__firestore_source,
__alloy_db_source,
__bigtable_source,
__parent,
__error_config,
__reconciliation_mode,
__update_mask,
__auto_generate_ids,
__id_field,
__force_refresh_content,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ImportDocumentsRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"inlineSource" => Ok(__FieldTag::__inline_source),
"inline_source" => Ok(__FieldTag::__inline_source),
"gcsSource" => Ok(__FieldTag::__gcs_source),
"gcs_source" => Ok(__FieldTag::__gcs_source),
"bigquerySource" => Ok(__FieldTag::__bigquery_source),
"bigquery_source" => Ok(__FieldTag::__bigquery_source),
"fhirStoreSource" => Ok(__FieldTag::__fhir_store_source),
"fhir_store_source" => Ok(__FieldTag::__fhir_store_source),
"spannerSource" => Ok(__FieldTag::__spanner_source),
"spanner_source" => Ok(__FieldTag::__spanner_source),
"cloudSqlSource" => Ok(__FieldTag::__cloud_sql_source),
"cloud_sql_source" => Ok(__FieldTag::__cloud_sql_source),
"firestoreSource" => Ok(__FieldTag::__firestore_source),
"firestore_source" => Ok(__FieldTag::__firestore_source),
"alloyDbSource" => Ok(__FieldTag::__alloy_db_source),
"alloy_db_source" => Ok(__FieldTag::__alloy_db_source),
"bigtableSource" => Ok(__FieldTag::__bigtable_source),
"bigtable_source" => Ok(__FieldTag::__bigtable_source),
"parent" => Ok(__FieldTag::__parent),
"errorConfig" => Ok(__FieldTag::__error_config),
"error_config" => Ok(__FieldTag::__error_config),
"reconciliationMode" => Ok(__FieldTag::__reconciliation_mode),
"reconciliation_mode" => Ok(__FieldTag::__reconciliation_mode),
"updateMask" => Ok(__FieldTag::__update_mask),
"update_mask" => Ok(__FieldTag::__update_mask),
"autoGenerateIds" => Ok(__FieldTag::__auto_generate_ids),
"auto_generate_ids" => Ok(__FieldTag::__auto_generate_ids),
"idField" => Ok(__FieldTag::__id_field),
"id_field" => Ok(__FieldTag::__id_field),
"forceRefreshContent" => Ok(__FieldTag::__force_refresh_content),
"force_refresh_content" => Ok(__FieldTag::__force_refresh_content),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ImportDocumentsRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ImportDocumentsRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__inline_source => {
if !fields.insert(__FieldTag::__inline_source) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for inline_source",
));
}
if result.source.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `source`, a oneof with full ID .google.cloud.discoveryengine.v1.ImportDocumentsRequest.inline_source, latest field was inlineSource",
));
}
result.source = std::option::Option::Some(
crate::model::import_documents_request::Source::InlineSource(
map.next_value::<std::option::Option<
std::boxed::Box<
crate::model::import_documents_request::InlineSource,
>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__gcs_source => {
if !fields.insert(__FieldTag::__gcs_source) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for gcs_source",
));
}
if result.source.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `source`, a oneof with full ID .google.cloud.discoveryengine.v1.ImportDocumentsRequest.gcs_source, latest field was gcsSource",
));
}
result.source = std::option::Option::Some(
crate::model::import_documents_request::Source::GcsSource(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::GcsSource>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__bigquery_source => {
if !fields.insert(__FieldTag::__bigquery_source) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for bigquery_source",
));
}
if result.source.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `source`, a oneof with full ID .google.cloud.discoveryengine.v1.ImportDocumentsRequest.bigquery_source, latest field was bigquerySource",
));
}
result.source = std::option::Option::Some(
crate::model::import_documents_request::Source::BigquerySource(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::BigQuerySource>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__fhir_store_source => {
if !fields.insert(__FieldTag::__fhir_store_source) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for fhir_store_source",
));
}
if result.source.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `source`, a oneof with full ID .google.cloud.discoveryengine.v1.ImportDocumentsRequest.fhir_store_source, latest field was fhirStoreSource",
));
}
result.source = std::option::Option::Some(
crate::model::import_documents_request::Source::FhirStoreSource(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::FhirStoreSource>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__spanner_source => {
if !fields.insert(__FieldTag::__spanner_source) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for spanner_source",
));
}
if result.source.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `source`, a oneof with full ID .google.cloud.discoveryengine.v1.ImportDocumentsRequest.spanner_source, latest field was spannerSource",
));
}
result.source = std::option::Option::Some(
crate::model::import_documents_request::Source::SpannerSource(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::SpannerSource>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__cloud_sql_source => {
if !fields.insert(__FieldTag::__cloud_sql_source) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cloud_sql_source",
));
}
if result.source.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `source`, a oneof with full ID .google.cloud.discoveryengine.v1.ImportDocumentsRequest.cloud_sql_source, latest field was cloudSqlSource",
));
}
result.source = std::option::Option::Some(
crate::model::import_documents_request::Source::CloudSqlSource(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::CloudSqlSource>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__firestore_source => {
if !fields.insert(__FieldTag::__firestore_source) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for firestore_source",
));
}
if result.source.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `source`, a oneof with full ID .google.cloud.discoveryengine.v1.ImportDocumentsRequest.firestore_source, latest field was firestoreSource",
));
}
result.source = std::option::Option::Some(
crate::model::import_documents_request::Source::FirestoreSource(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::FirestoreSource>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__alloy_db_source => {
if !fields.insert(__FieldTag::__alloy_db_source) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for alloy_db_source",
));
}
if result.source.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `source`, a oneof with full ID .google.cloud.discoveryengine.v1.ImportDocumentsRequest.alloy_db_source, latest field was alloyDbSource",
));
}
result.source = std::option::Option::Some(
crate::model::import_documents_request::Source::AlloyDbSource(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::AlloyDbSource>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__bigtable_source => {
if !fields.insert(__FieldTag::__bigtable_source) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for bigtable_source",
));
}
if result.source.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `source`, a oneof with full ID .google.cloud.discoveryengine.v1.ImportDocumentsRequest.bigtable_source, latest field was bigtableSource",
));
}
result.source = std::option::Option::Some(
crate::model::import_documents_request::Source::BigtableSource(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::BigtableSource>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__error_config => {
if !fields.insert(__FieldTag::__error_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for error_config",
));
}
result.error_config = map
.next_value::<std::option::Option<crate::model::ImportErrorConfig>>(
)?;
}
__FieldTag::__reconciliation_mode => {
if !fields.insert(__FieldTag::__reconciliation_mode) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for reconciliation_mode",
));
}
result.reconciliation_mode = map
.next_value::<std::option::Option<
crate::model::import_documents_request::ReconciliationMode,
>>()?
.unwrap_or_default();
}
__FieldTag::__update_mask => {
if !fields.insert(__FieldTag::__update_mask) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_mask",
));
}
result.update_mask =
map.next_value::<std::option::Option<wkt::FieldMask>>()?;
}
__FieldTag::__auto_generate_ids => {
if !fields.insert(__FieldTag::__auto_generate_ids) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for auto_generate_ids",
));
}
result.auto_generate_ids = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__id_field => {
if !fields.insert(__FieldTag::__id_field) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for id_field",
));
}
result.id_field = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__force_refresh_content => {
if !fields.insert(__FieldTag::__force_refresh_content) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for force_refresh_content",
));
}
result.force_refresh_content = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "document-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::import_documents_request::InlineSource {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__documents,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for InlineSource")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"documents" => Ok(__FieldTag::__documents),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::import_documents_request::InlineSource;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct InlineSource")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__documents => {
if !fields.insert(__FieldTag::__documents) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for documents",
));
}
result.documents = map.next_value::<std::option::Option<std::vec::Vec<crate::model::Document>>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "document-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ImportDocumentsResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__error_samples,
__error_config,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ImportDocumentsResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"errorSamples" => Ok(__FieldTag::__error_samples),
"error_samples" => Ok(__FieldTag::__error_samples),
"errorConfig" => Ok(__FieldTag::__error_config),
"error_config" => Ok(__FieldTag::__error_config),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ImportDocumentsResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ImportDocumentsResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__error_samples => {
if !fields.insert(__FieldTag::__error_samples) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for error_samples",
));
}
result.error_samples =
map.next_value::<std::option::Option<
std::vec::Vec<google_cloud_rpc::model::Status>,
>>()?
.unwrap_or_default();
}
__FieldTag::__error_config => {
if !fields.insert(__FieldTag::__error_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for error_config",
));
}
result.error_config = map
.next_value::<std::option::Option<crate::model::ImportErrorConfig>>(
)?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "completion-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ImportSuggestionDenyListEntriesRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__inline_source,
__gcs_source,
__parent,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter
.write_str("a field name for ImportSuggestionDenyListEntriesRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"inlineSource" => Ok(__FieldTag::__inline_source),
"inline_source" => Ok(__FieldTag::__inline_source),
"gcsSource" => Ok(__FieldTag::__gcs_source),
"gcs_source" => Ok(__FieldTag::__gcs_source),
"parent" => Ok(__FieldTag::__parent),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ImportSuggestionDenyListEntriesRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ImportSuggestionDenyListEntriesRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__inline_source => {
if !fields.insert(__FieldTag::__inline_source) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for inline_source",
));
}
if result.source.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `source`, a oneof with full ID .google.cloud.discoveryengine.v1.ImportSuggestionDenyListEntriesRequest.inline_source, latest field was inlineSource",
));
}
result.source = std::option::Option::Some(
crate::model::import_suggestion_deny_list_entries_request::Source::InlineSource(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::import_suggestion_deny_list_entries_request::InlineSource>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__gcs_source => {
if !fields.insert(__FieldTag::__gcs_source) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for gcs_source",
));
}
if result.source.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `source`, a oneof with full ID .google.cloud.discoveryengine.v1.ImportSuggestionDenyListEntriesRequest.gcs_source, latest field was gcsSource",
));
}
result.source = std::option::Option::Some(
crate::model::import_suggestion_deny_list_entries_request::Source::GcsSource(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::GcsSource>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "completion-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::import_suggestion_deny_list_entries_request::InlineSource
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__entries,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for InlineSource")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"entries" => Ok(__FieldTag::__entries),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::import_suggestion_deny_list_entries_request::InlineSource;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct InlineSource")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__entries => {
if !fields.insert(__FieldTag::__entries) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for entries",
));
}
result.entries = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::SuggestionDenyListEntry>,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "completion-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ImportSuggestionDenyListEntriesResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__error_samples,
__imported_entries_count,
__failed_entries_count,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter
.write_str("a field name for ImportSuggestionDenyListEntriesResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"errorSamples" => Ok(__FieldTag::__error_samples),
"error_samples" => Ok(__FieldTag::__error_samples),
"importedEntriesCount" => Ok(__FieldTag::__imported_entries_count),
"imported_entries_count" => Ok(__FieldTag::__imported_entries_count),
"failedEntriesCount" => Ok(__FieldTag::__failed_entries_count),
"failed_entries_count" => Ok(__FieldTag::__failed_entries_count),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ImportSuggestionDenyListEntriesResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ImportSuggestionDenyListEntriesResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__error_samples => {
if !fields.insert(__FieldTag::__error_samples) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for error_samples",
));
}
result.error_samples =
map.next_value::<std::option::Option<
std::vec::Vec<google_cloud_rpc::model::Status>,
>>()?
.unwrap_or_default();
}
__FieldTag::__imported_entries_count => {
if !fields.insert(__FieldTag::__imported_entries_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for imported_entries_count",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.imported_entries_count =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__failed_entries_count => {
if !fields.insert(__FieldTag::__failed_entries_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for failed_entries_count",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.failed_entries_count =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "completion-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ImportSuggestionDenyListEntriesMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__create_time,
__update_time,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter
.write_str("a field name for ImportSuggestionDenyListEntriesMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"updateTime" => Ok(__FieldTag::__update_time),
"update_time" => Ok(__FieldTag::__update_time),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ImportSuggestionDenyListEntriesMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ImportSuggestionDenyListEntriesMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__update_time => {
if !fields.insert(__FieldTag::__update_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_time",
));
}
result.update_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "completion-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ImportCompletionSuggestionsRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__inline_source,
__gcs_source,
__bigquery_source,
__parent,
__error_config,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ImportCompletionSuggestionsRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"inlineSource" => Ok(__FieldTag::__inline_source),
"inline_source" => Ok(__FieldTag::__inline_source),
"gcsSource" => Ok(__FieldTag::__gcs_source),
"gcs_source" => Ok(__FieldTag::__gcs_source),
"bigquerySource" => Ok(__FieldTag::__bigquery_source),
"bigquery_source" => Ok(__FieldTag::__bigquery_source),
"parent" => Ok(__FieldTag::__parent),
"errorConfig" => Ok(__FieldTag::__error_config),
"error_config" => Ok(__FieldTag::__error_config),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ImportCompletionSuggestionsRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ImportCompletionSuggestionsRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__inline_source => {
if !fields.insert(__FieldTag::__inline_source) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for inline_source",
));
}
if result.source.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `source`, a oneof with full ID .google.cloud.discoveryengine.v1.ImportCompletionSuggestionsRequest.inline_source, latest field was inlineSource",
));
}
result.source = std::option::Option::Some(
crate::model::import_completion_suggestions_request::Source::InlineSource(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::import_completion_suggestions_request::InlineSource>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__gcs_source => {
if !fields.insert(__FieldTag::__gcs_source) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for gcs_source",
));
}
if result.source.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `source`, a oneof with full ID .google.cloud.discoveryengine.v1.ImportCompletionSuggestionsRequest.gcs_source, latest field was gcsSource",
));
}
result.source = std::option::Option::Some(
crate::model::import_completion_suggestions_request::Source::GcsSource(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::GcsSource>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__bigquery_source => {
if !fields.insert(__FieldTag::__bigquery_source) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for bigquery_source",
));
}
if result.source.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `source`, a oneof with full ID .google.cloud.discoveryengine.v1.ImportCompletionSuggestionsRequest.bigquery_source, latest field was bigquerySource",
));
}
result.source = std::option::Option::Some(
crate::model::import_completion_suggestions_request::Source::BigquerySource(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::BigQuerySource>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__error_config => {
if !fields.insert(__FieldTag::__error_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for error_config",
));
}
result.error_config = map
.next_value::<std::option::Option<crate::model::ImportErrorConfig>>(
)?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "completion-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::import_completion_suggestions_request::InlineSource
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__suggestions,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for InlineSource")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"suggestions" => Ok(__FieldTag::__suggestions),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::import_completion_suggestions_request::InlineSource;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct InlineSource")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__suggestions => {
if !fields.insert(__FieldTag::__suggestions) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for suggestions",
));
}
result.suggestions = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::CompletionSuggestion>,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "completion-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ImportCompletionSuggestionsResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__error_samples,
__error_config,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ImportCompletionSuggestionsResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"errorSamples" => Ok(__FieldTag::__error_samples),
"error_samples" => Ok(__FieldTag::__error_samples),
"errorConfig" => Ok(__FieldTag::__error_config),
"error_config" => Ok(__FieldTag::__error_config),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ImportCompletionSuggestionsResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ImportCompletionSuggestionsResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__error_samples => {
if !fields.insert(__FieldTag::__error_samples) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for error_samples",
));
}
result.error_samples =
map.next_value::<std::option::Option<
std::vec::Vec<google_cloud_rpc::model::Status>,
>>()?
.unwrap_or_default();
}
__FieldTag::__error_config => {
if !fields.insert(__FieldTag::__error_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for error_config",
));
}
result.error_config = map
.next_value::<std::option::Option<crate::model::ImportErrorConfig>>(
)?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "completion-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ImportCompletionSuggestionsMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__create_time,
__update_time,
__success_count,
__failure_count,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ImportCompletionSuggestionsMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"updateTime" => Ok(__FieldTag::__update_time),
"update_time" => Ok(__FieldTag::__update_time),
"successCount" => Ok(__FieldTag::__success_count),
"success_count" => Ok(__FieldTag::__success_count),
"failureCount" => Ok(__FieldTag::__failure_count),
"failure_count" => Ok(__FieldTag::__failure_count),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ImportCompletionSuggestionsMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ImportCompletionSuggestionsMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__update_time => {
if !fields.insert(__FieldTag::__update_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_time",
));
}
result.update_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__success_count => {
if !fields.insert(__FieldTag::__success_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for success_count",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.success_count =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__failure_count => {
if !fields.insert(__FieldTag::__failure_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for failure_count",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.failure_count =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "project-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::Project {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
__create_time,
__provision_completion_time,
__service_terms_map,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Project")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"provisionCompletionTime" => {
Ok(__FieldTag::__provision_completion_time)
}
"provision_completion_time" => {
Ok(__FieldTag::__provision_completion_time)
}
"serviceTermsMap" => Ok(__FieldTag::__service_terms_map),
"service_terms_map" => Ok(__FieldTag::__service_terms_map),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Project;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Project")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__provision_completion_time => {
if !fields.insert(__FieldTag::__provision_completion_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for provision_completion_time",
));
}
result.provision_completion_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__service_terms_map => {
if !fields.insert(__FieldTag::__service_terms_map) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for service_terms_map",
));
}
result.service_terms_map = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
crate::model::project::ServiceTerms,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "project-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::project::ServiceTerms {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__id,
__version,
__state,
__accept_time,
__decline_time,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ServiceTerms")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"id" => Ok(__FieldTag::__id),
"version" => Ok(__FieldTag::__version),
"state" => Ok(__FieldTag::__state),
"acceptTime" => Ok(__FieldTag::__accept_time),
"accept_time" => Ok(__FieldTag::__accept_time),
"declineTime" => Ok(__FieldTag::__decline_time),
"decline_time" => Ok(__FieldTag::__decline_time),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::project::ServiceTerms;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ServiceTerms")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__id => {
if !fields.insert(__FieldTag::__id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for id",
));
}
result.id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__version => {
if !fields.insert(__FieldTag::__version) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for version",
));
}
result.version = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__state => {
if !fields.insert(__FieldTag::__state) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for state",
));
}
result.state =
map.next_value::<std::option::Option<
crate::model::project::service_terms::State,
>>()?
.unwrap_or_default();
}
__FieldTag::__accept_time => {
if !fields.insert(__FieldTag::__accept_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for accept_time",
));
}
result.accept_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__decline_time => {
if !fields.insert(__FieldTag::__decline_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for decline_time",
));
}
result.decline_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "project-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ProvisionProjectRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
__accept_data_use_terms,
__data_use_terms_version,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ProvisionProjectRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
"acceptDataUseTerms" => Ok(__FieldTag::__accept_data_use_terms),
"accept_data_use_terms" => Ok(__FieldTag::__accept_data_use_terms),
"dataUseTermsVersion" => Ok(__FieldTag::__data_use_terms_version),
"data_use_terms_version" => Ok(__FieldTag::__data_use_terms_version),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ProvisionProjectRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ProvisionProjectRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__accept_data_use_terms => {
if !fields.insert(__FieldTag::__accept_data_use_terms) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for accept_data_use_terms",
));
}
result.accept_data_use_terms = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__data_use_terms_version => {
if !fields.insert(__FieldTag::__data_use_terms_version) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for data_use_terms_version",
));
}
result.data_use_terms_version = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "project-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ProvisionProjectMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ProvisionProjectMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
Ok(__FieldTag::Unknown(value.to_string()))
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ProvisionProjectMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ProvisionProjectMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "user-event-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::PurgeUserEventsRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__parent,
__filter,
__force,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for PurgeUserEventsRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"parent" => Ok(__FieldTag::__parent),
"filter" => Ok(__FieldTag::__filter),
"force" => Ok(__FieldTag::__force),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::PurgeUserEventsRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct PurgeUserEventsRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__filter => {
if !fields.insert(__FieldTag::__filter) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for filter",
));
}
result.filter = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__force => {
if !fields.insert(__FieldTag::__force) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for force",
));
}
result.force = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "user-event-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::PurgeUserEventsResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__purge_count,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for PurgeUserEventsResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"purgeCount" => Ok(__FieldTag::__purge_count),
"purge_count" => Ok(__FieldTag::__purge_count),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::PurgeUserEventsResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct PurgeUserEventsResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__purge_count => {
if !fields.insert(__FieldTag::__purge_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for purge_count",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.purge_count = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "user-event-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::PurgeUserEventsMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__create_time,
__update_time,
__success_count,
__failure_count,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for PurgeUserEventsMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"updateTime" => Ok(__FieldTag::__update_time),
"update_time" => Ok(__FieldTag::__update_time),
"successCount" => Ok(__FieldTag::__success_count),
"success_count" => Ok(__FieldTag::__success_count),
"failureCount" => Ok(__FieldTag::__failure_count),
"failure_count" => Ok(__FieldTag::__failure_count),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::PurgeUserEventsMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct PurgeUserEventsMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__update_time => {
if !fields.insert(__FieldTag::__update_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_time",
));
}
result.update_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__success_count => {
if !fields.insert(__FieldTag::__success_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for success_count",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.success_count =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__failure_count => {
if !fields.insert(__FieldTag::__failure_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for failure_count",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.failure_count =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "document-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::PurgeErrorConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__gcs_prefix,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for PurgeErrorConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"gcsPrefix" => Ok(__FieldTag::__gcs_prefix),
"gcs_prefix" => Ok(__FieldTag::__gcs_prefix),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::PurgeErrorConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct PurgeErrorConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__gcs_prefix => {
if !fields.insert(__FieldTag::__gcs_prefix) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for gcs_prefix",
));
}
if result.destination.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `destination`, a oneof with full ID .google.cloud.discoveryengine.v1.PurgeErrorConfig.gcs_prefix, latest field was gcsPrefix",
));
}
result.destination = std::option::Option::Some(
crate::model::purge_error_config::Destination::GcsPrefix(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "document-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::PurgeDocumentsRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__gcs_source,
__inline_source,
__parent,
__filter,
__error_config,
__force,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for PurgeDocumentsRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"gcsSource" => Ok(__FieldTag::__gcs_source),
"gcs_source" => Ok(__FieldTag::__gcs_source),
"inlineSource" => Ok(__FieldTag::__inline_source),
"inline_source" => Ok(__FieldTag::__inline_source),
"parent" => Ok(__FieldTag::__parent),
"filter" => Ok(__FieldTag::__filter),
"errorConfig" => Ok(__FieldTag::__error_config),
"error_config" => Ok(__FieldTag::__error_config),
"force" => Ok(__FieldTag::__force),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::PurgeDocumentsRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct PurgeDocumentsRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__gcs_source => {
if !fields.insert(__FieldTag::__gcs_source) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for gcs_source",
));
}
if result.source.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `source`, a oneof with full ID .google.cloud.discoveryengine.v1.PurgeDocumentsRequest.gcs_source, latest field was gcsSource",
));
}
result.source = std::option::Option::Some(
crate::model::purge_documents_request::Source::GcsSource(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::GcsSource>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__inline_source => {
if !fields.insert(__FieldTag::__inline_source) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for inline_source",
));
}
if result.source.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `source`, a oneof with full ID .google.cloud.discoveryengine.v1.PurgeDocumentsRequest.inline_source, latest field was inlineSource",
));
}
result.source = std::option::Option::Some(
crate::model::purge_documents_request::Source::InlineSource(
map.next_value::<std::option::Option<
std::boxed::Box<
crate::model::purge_documents_request::InlineSource,
>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__filter => {
if !fields.insert(__FieldTag::__filter) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for filter",
));
}
result.filter = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__error_config => {
if !fields.insert(__FieldTag::__error_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for error_config",
));
}
result.error_config = map
.next_value::<std::option::Option<crate::model::PurgeErrorConfig>>(
)?;
}
__FieldTag::__force => {
if !fields.insert(__FieldTag::__force) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for force",
));
}
result.force = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "document-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::purge_documents_request::InlineSource {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__documents,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for InlineSource")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"documents" => Ok(__FieldTag::__documents),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::purge_documents_request::InlineSource;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct InlineSource")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__documents => {
if !fields.insert(__FieldTag::__documents) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for documents",
));
}
result.documents = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "document-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::PurgeDocumentsResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__purge_count,
__purge_sample,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for PurgeDocumentsResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"purgeCount" => Ok(__FieldTag::__purge_count),
"purge_count" => Ok(__FieldTag::__purge_count),
"purgeSample" => Ok(__FieldTag::__purge_sample),
"purge_sample" => Ok(__FieldTag::__purge_sample),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::PurgeDocumentsResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct PurgeDocumentsResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__purge_count => {
if !fields.insert(__FieldTag::__purge_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for purge_count",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.purge_count = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__purge_sample => {
if !fields.insert(__FieldTag::__purge_sample) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for purge_sample",
));
}
result.purge_sample = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "document-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::PurgeDocumentsMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__create_time,
__update_time,
__success_count,
__failure_count,
__ignored_count,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for PurgeDocumentsMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"updateTime" => Ok(__FieldTag::__update_time),
"update_time" => Ok(__FieldTag::__update_time),
"successCount" => Ok(__FieldTag::__success_count),
"success_count" => Ok(__FieldTag::__success_count),
"failureCount" => Ok(__FieldTag::__failure_count),
"failure_count" => Ok(__FieldTag::__failure_count),
"ignoredCount" => Ok(__FieldTag::__ignored_count),
"ignored_count" => Ok(__FieldTag::__ignored_count),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::PurgeDocumentsMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct PurgeDocumentsMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__update_time => {
if !fields.insert(__FieldTag::__update_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_time",
));
}
result.update_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__success_count => {
if !fields.insert(__FieldTag::__success_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for success_count",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.success_count =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__failure_count => {
if !fields.insert(__FieldTag::__failure_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for failure_count",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.failure_count =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__ignored_count => {
if !fields.insert(__FieldTag::__ignored_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for ignored_count",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.ignored_count =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "completion-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::PurgeSuggestionDenyListEntriesRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__parent,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter
.write_str("a field name for PurgeSuggestionDenyListEntriesRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"parent" => Ok(__FieldTag::__parent),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::PurgeSuggestionDenyListEntriesRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct PurgeSuggestionDenyListEntriesRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "completion-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::PurgeSuggestionDenyListEntriesResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__purge_count,
__error_samples,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter
.write_str("a field name for PurgeSuggestionDenyListEntriesResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"purgeCount" => Ok(__FieldTag::__purge_count),
"purge_count" => Ok(__FieldTag::__purge_count),
"errorSamples" => Ok(__FieldTag::__error_samples),
"error_samples" => Ok(__FieldTag::__error_samples),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::PurgeSuggestionDenyListEntriesResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct PurgeSuggestionDenyListEntriesResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__purge_count => {
if !fields.insert(__FieldTag::__purge_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for purge_count",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.purge_count = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__error_samples => {
if !fields.insert(__FieldTag::__error_samples) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for error_samples",
));
}
result.error_samples =
map.next_value::<std::option::Option<
std::vec::Vec<google_cloud_rpc::model::Status>,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "completion-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::PurgeSuggestionDenyListEntriesMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__create_time,
__update_time,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter
.write_str("a field name for PurgeSuggestionDenyListEntriesMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"updateTime" => Ok(__FieldTag::__update_time),
"update_time" => Ok(__FieldTag::__update_time),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::PurgeSuggestionDenyListEntriesMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct PurgeSuggestionDenyListEntriesMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__update_time => {
if !fields.insert(__FieldTag::__update_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_time",
));
}
result.update_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "completion-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::PurgeCompletionSuggestionsRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__parent,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for PurgeCompletionSuggestionsRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"parent" => Ok(__FieldTag::__parent),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::PurgeCompletionSuggestionsRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct PurgeCompletionSuggestionsRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "completion-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::PurgeCompletionSuggestionsResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__purge_succeeded,
__error_samples,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for PurgeCompletionSuggestionsResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"purgeSucceeded" => Ok(__FieldTag::__purge_succeeded),
"purge_succeeded" => Ok(__FieldTag::__purge_succeeded),
"errorSamples" => Ok(__FieldTag::__error_samples),
"error_samples" => Ok(__FieldTag::__error_samples),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::PurgeCompletionSuggestionsResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct PurgeCompletionSuggestionsResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__purge_succeeded => {
if !fields.insert(__FieldTag::__purge_succeeded) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for purge_succeeded",
));
}
result.purge_succeeded = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__error_samples => {
if !fields.insert(__FieldTag::__error_samples) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for error_samples",
));
}
result.error_samples =
map.next_value::<std::option::Option<
std::vec::Vec<google_cloud_rpc::model::Status>,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "completion-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::PurgeCompletionSuggestionsMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__create_time,
__update_time,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for PurgeCompletionSuggestionsMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"updateTime" => Ok(__FieldTag::__update_time),
"update_time" => Ok(__FieldTag::__update_time),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::PurgeCompletionSuggestionsMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct PurgeCompletionSuggestionsMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__update_time => {
if !fields.insert(__FieldTag::__update_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_time",
));
}
result.update_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "rank-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::RankingRecord {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__id,
__title,
__content,
__score,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for RankingRecord")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"id" => Ok(__FieldTag::__id),
"title" => Ok(__FieldTag::__title),
"content" => Ok(__FieldTag::__content),
"score" => Ok(__FieldTag::__score),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::RankingRecord;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct RankingRecord")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__id => {
if !fields.insert(__FieldTag::__id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for id",
));
}
result.id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__title => {
if !fields.insert(__FieldTag::__title) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for title",
));
}
result.title = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__content => {
if !fields.insert(__FieldTag::__content) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for content",
));
}
result.content = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__score => {
if !fields.insert(__FieldTag::__score) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for score",
));
}
struct __With(std::option::Option<f32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F32> >::deserialize(deserializer).map(__With)
}
}
result.score = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "rank-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::RankRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__ranking_config,
__model,
__top_n,
__query,
__records,
__ignore_record_details_in_response,
__user_labels,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for RankRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"rankingConfig" => Ok(__FieldTag::__ranking_config),
"ranking_config" => Ok(__FieldTag::__ranking_config),
"model" => Ok(__FieldTag::__model),
"topN" => Ok(__FieldTag::__top_n),
"top_n" => Ok(__FieldTag::__top_n),
"query" => Ok(__FieldTag::__query),
"records" => Ok(__FieldTag::__records),
"ignoreRecordDetailsInResponse" => {
Ok(__FieldTag::__ignore_record_details_in_response)
}
"ignore_record_details_in_response" => {
Ok(__FieldTag::__ignore_record_details_in_response)
}
"userLabels" => Ok(__FieldTag::__user_labels),
"user_labels" => Ok(__FieldTag::__user_labels),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::RankRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct RankRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__ranking_config => {
if !fields.insert(__FieldTag::__ranking_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for ranking_config",
));
}
result.ranking_config = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__model => {
if !fields.insert(__FieldTag::__model) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for model",
));
}
result.model = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__top_n => {
if !fields.insert(__FieldTag::__top_n) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for top_n",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.top_n = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__query => {
if !fields.insert(__FieldTag::__query) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for query",
));
}
result.query = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__records => {
if !fields.insert(__FieldTag::__records) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for records",
));
}
result.records = map.next_value::<std::option::Option<std::vec::Vec<crate::model::RankingRecord>>>()?.unwrap_or_default();
}
__FieldTag::__ignore_record_details_in_response => {
if !fields.insert(__FieldTag::__ignore_record_details_in_response) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for ignore_record_details_in_response",
));
}
result.ignore_record_details_in_response = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__user_labels => {
if !fields.insert(__FieldTag::__user_labels) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for user_labels",
));
}
result.user_labels = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
std::string::String,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "rank-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::RankResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__records,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for RankResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"records" => Ok(__FieldTag::__records),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::RankResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct RankResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__records => {
if !fields.insert(__FieldTag::__records) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for records",
));
}
result.records = map.next_value::<std::option::Option<std::vec::Vec<crate::model::RankingRecord>>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "recommendation-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::RecommendRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__serving_config,
__user_event,
__page_size,
__filter,
__validate_only,
__params,
__user_labels,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for RecommendRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"servingConfig" => Ok(__FieldTag::__serving_config),
"serving_config" => Ok(__FieldTag::__serving_config),
"userEvent" => Ok(__FieldTag::__user_event),
"user_event" => Ok(__FieldTag::__user_event),
"pageSize" => Ok(__FieldTag::__page_size),
"page_size" => Ok(__FieldTag::__page_size),
"filter" => Ok(__FieldTag::__filter),
"validateOnly" => Ok(__FieldTag::__validate_only),
"validate_only" => Ok(__FieldTag::__validate_only),
"params" => Ok(__FieldTag::__params),
"userLabels" => Ok(__FieldTag::__user_labels),
"user_labels" => Ok(__FieldTag::__user_labels),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::RecommendRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct RecommendRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__serving_config => {
if !fields.insert(__FieldTag::__serving_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for serving_config",
));
}
result.serving_config = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__user_event => {
if !fields.insert(__FieldTag::__user_event) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for user_event",
));
}
result.user_event =
map.next_value::<std::option::Option<crate::model::UserEvent>>()?;
}
__FieldTag::__page_size => {
if !fields.insert(__FieldTag::__page_size) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_size",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.page_size = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__filter => {
if !fields.insert(__FieldTag::__filter) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for filter",
));
}
result.filter = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__validate_only => {
if !fields.insert(__FieldTag::__validate_only) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for validate_only",
));
}
result.validate_only = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__params => {
if !fields.insert(__FieldTag::__params) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for params",
));
}
result.params = map
.next_value::<std::option::Option<
std::collections::HashMap<std::string::String, wkt::Value>,
>>()?
.unwrap_or_default();
}
__FieldTag::__user_labels => {
if !fields.insert(__FieldTag::__user_labels) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for user_labels",
));
}
result.user_labels = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
std::string::String,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "recommendation-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::RecommendResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__results,
__attribution_token,
__missing_ids,
__validate_only,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for RecommendResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"results" => Ok(__FieldTag::__results),
"attributionToken" => Ok(__FieldTag::__attribution_token),
"attribution_token" => Ok(__FieldTag::__attribution_token),
"missingIds" => Ok(__FieldTag::__missing_ids),
"missing_ids" => Ok(__FieldTag::__missing_ids),
"validateOnly" => Ok(__FieldTag::__validate_only),
"validate_only" => Ok(__FieldTag::__validate_only),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::RecommendResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct RecommendResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__results => {
if !fields.insert(__FieldTag::__results) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for results",
));
}
result.results = map
.next_value::<std::option::Option<
std::vec::Vec<
crate::model::recommend_response::RecommendationResult,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::__attribution_token => {
if !fields.insert(__FieldTag::__attribution_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for attribution_token",
));
}
result.attribution_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__missing_ids => {
if !fields.insert(__FieldTag::__missing_ids) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for missing_ids",
));
}
result.missing_ids = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__validate_only => {
if !fields.insert(__FieldTag::__validate_only) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for validate_only",
));
}
result.validate_only = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "recommendation-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::recommend_response::RecommendationResult {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__id,
__document,
__metadata,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for RecommendationResult")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"id" => Ok(__FieldTag::__id),
"document" => Ok(__FieldTag::__document),
"metadata" => Ok(__FieldTag::__metadata),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::recommend_response::RecommendationResult;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct RecommendationResult")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__id => {
if !fields.insert(__FieldTag::__id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for id",
));
}
result.id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__document => {
if !fields.insert(__FieldTag::__document) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for document",
));
}
result.document =
map.next_value::<std::option::Option<crate::model::Document>>()?;
}
__FieldTag::__metadata => {
if !fields.insert(__FieldTag::__metadata) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for metadata",
));
}
result.metadata = map
.next_value::<std::option::Option<
std::collections::HashMap<std::string::String, wkt::Value>,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::SafetyRating {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__category,
__probability,
__probability_score,
__severity,
__severity_score,
__blocked,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SafetyRating")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"category" => Ok(__FieldTag::__category),
"probability" => Ok(__FieldTag::__probability),
"probabilityScore" => Ok(__FieldTag::__probability_score),
"probability_score" => Ok(__FieldTag::__probability_score),
"severity" => Ok(__FieldTag::__severity),
"severityScore" => Ok(__FieldTag::__severity_score),
"severity_score" => Ok(__FieldTag::__severity_score),
"blocked" => Ok(__FieldTag::__blocked),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::SafetyRating;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SafetyRating")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__category => {
if !fields.insert(__FieldTag::__category) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for category",
));
}
result.category = map
.next_value::<std::option::Option<crate::model::HarmCategory>>()?
.unwrap_or_default();
}
__FieldTag::__probability => {
if !fields.insert(__FieldTag::__probability) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for probability",
));
}
result.probability =
map.next_value::<std::option::Option<
crate::model::safety_rating::HarmProbability,
>>()?
.unwrap_or_default();
}
__FieldTag::__probability_score => {
if !fields.insert(__FieldTag::__probability_score) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for probability_score",
));
}
struct __With(std::option::Option<f32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F32> >::deserialize(deserializer).map(__With)
}
}
result.probability_score =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__severity => {
if !fields.insert(__FieldTag::__severity) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for severity",
));
}
result.severity = map.next_value::<std::option::Option<crate::model::safety_rating::HarmSeverity>>()?.unwrap_or_default();
}
__FieldTag::__severity_score => {
if !fields.insert(__FieldTag::__severity_score) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for severity_score",
));
}
struct __With(std::option::Option<f32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F32> >::deserialize(deserializer).map(__With)
}
}
result.severity_score =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__blocked => {
if !fields.insert(__FieldTag::__blocked) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for blocked",
));
}
result.blocked = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "data-store-service", feature = "schema-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::Schema {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__struct_schema,
__json_schema,
__name,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Schema")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"structSchema" => Ok(__FieldTag::__struct_schema),
"struct_schema" => Ok(__FieldTag::__struct_schema),
"jsonSchema" => Ok(__FieldTag::__json_schema),
"json_schema" => Ok(__FieldTag::__json_schema),
"name" => Ok(__FieldTag::__name),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Schema;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Schema")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__struct_schema => {
if !fields.insert(__FieldTag::__struct_schema) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for struct_schema",
));
}
if result.schema.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `schema`, a oneof with full ID .google.cloud.discoveryengine.v1.Schema.struct_schema, latest field was structSchema",
));
}
result.schema = std::option::Option::Some(
crate::model::schema::Schema::StructSchema(
map.next_value::<std::option::Option<std::boxed::Box<wkt::Struct>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__json_schema => {
if !fields.insert(__FieldTag::__json_schema) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for json_schema",
));
}
if result.schema.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `schema`, a oneof with full ID .google.cloud.discoveryengine.v1.Schema.json_schema, latest field was jsonSchema",
));
}
result.schema = std::option::Option::Some(
crate::model::schema::Schema::JsonSchema(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "schema-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::GetSchemaRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for GetSchemaRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::GetSchemaRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GetSchemaRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "schema-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ListSchemasRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__parent,
__page_size,
__page_token,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ListSchemasRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"parent" => Ok(__FieldTag::__parent),
"pageSize" => Ok(__FieldTag::__page_size),
"page_size" => Ok(__FieldTag::__page_size),
"pageToken" => Ok(__FieldTag::__page_token),
"page_token" => Ok(__FieldTag::__page_token),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListSchemasRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListSchemasRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__page_size => {
if !fields.insert(__FieldTag::__page_size) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_size",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.page_size = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__page_token => {
if !fields.insert(__FieldTag::__page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_token",
));
}
result.page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "schema-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ListSchemasResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__schemas,
__next_page_token,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ListSchemasResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"schemas" => Ok(__FieldTag::__schemas),
"nextPageToken" => Ok(__FieldTag::__next_page_token),
"next_page_token" => Ok(__FieldTag::__next_page_token),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListSchemasResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListSchemasResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__schemas => {
if !fields.insert(__FieldTag::__schemas) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for schemas",
));
}
result.schemas = map.next_value::<std::option::Option<std::vec::Vec<crate::model::Schema>>>()?.unwrap_or_default();
}
__FieldTag::__next_page_token => {
if !fields.insert(__FieldTag::__next_page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for next_page_token",
));
}
result.next_page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "schema-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::CreateSchemaRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__parent,
__schema,
__schema_id,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for CreateSchemaRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"parent" => Ok(__FieldTag::__parent),
"schema" => Ok(__FieldTag::__schema),
"schemaId" => Ok(__FieldTag::__schema_id),
"schema_id" => Ok(__FieldTag::__schema_id),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CreateSchemaRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CreateSchemaRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__schema => {
if !fields.insert(__FieldTag::__schema) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for schema",
));
}
result.schema =
map.next_value::<std::option::Option<crate::model::Schema>>()?;
}
__FieldTag::__schema_id => {
if !fields.insert(__FieldTag::__schema_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for schema_id",
));
}
result.schema_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "schema-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::UpdateSchemaRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__schema,
__allow_missing,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for UpdateSchemaRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"schema" => Ok(__FieldTag::__schema),
"allowMissing" => Ok(__FieldTag::__allow_missing),
"allow_missing" => Ok(__FieldTag::__allow_missing),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::UpdateSchemaRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct UpdateSchemaRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__schema => {
if !fields.insert(__FieldTag::__schema) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for schema",
));
}
result.schema =
map.next_value::<std::option::Option<crate::model::Schema>>()?;
}
__FieldTag::__allow_missing => {
if !fields.insert(__FieldTag::__allow_missing) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for allow_missing",
));
}
result.allow_missing = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "schema-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::DeleteSchemaRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DeleteSchemaRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DeleteSchemaRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DeleteSchemaRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "schema-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::CreateSchemaMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__create_time,
__update_time,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for CreateSchemaMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"updateTime" => Ok(__FieldTag::__update_time),
"update_time" => Ok(__FieldTag::__update_time),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CreateSchemaMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CreateSchemaMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__update_time => {
if !fields.insert(__FieldTag::__update_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_time",
));
}
result.update_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "schema-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::UpdateSchemaMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__create_time,
__update_time,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for UpdateSchemaMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"updateTime" => Ok(__FieldTag::__update_time),
"update_time" => Ok(__FieldTag::__update_time),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::UpdateSchemaMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct UpdateSchemaMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__update_time => {
if !fields.insert(__FieldTag::__update_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_time",
));
}
result.update_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "schema-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::DeleteSchemaMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__create_time,
__update_time,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DeleteSchemaMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"updateTime" => Ok(__FieldTag::__update_time),
"update_time" => Ok(__FieldTag::__update_time),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DeleteSchemaMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DeleteSchemaMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__update_time => {
if !fields.insert(__FieldTag::__update_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_time",
));
}
result.update_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "assistant-service",
feature = "conversational-search-service",
feature = "search-service",
feature = "serving-config-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::SearchRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__serving_config,
__branch,
__query,
__page_categories,
__image_query,
__page_size,
__page_token,
__offset,
__one_box_page_size,
__data_store_specs,
__filter,
__canonical_filter,
__order_by,
__user_info,
__language_code,
__facet_specs,
__boost_spec,
__params,
__query_expansion_spec,
__spell_correction_spec,
__user_pseudo_id,
__content_search_spec,
__ranking_expression,
__ranking_expression_backend,
__safe_search,
__user_labels,
__natural_language_query_understanding_spec,
__search_as_you_type_spec,
__display_spec,
__crowding_specs,
__session,
__session_spec,
__relevance_threshold,
__relevance_score_spec,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SearchRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"servingConfig" => Ok(__FieldTag::__serving_config),
"serving_config" => Ok(__FieldTag::__serving_config),
"branch" => Ok(__FieldTag::__branch),
"query" => Ok(__FieldTag::__query),
"pageCategories" => Ok(__FieldTag::__page_categories),
"page_categories" => Ok(__FieldTag::__page_categories),
"imageQuery" => Ok(__FieldTag::__image_query),
"image_query" => Ok(__FieldTag::__image_query),
"pageSize" => Ok(__FieldTag::__page_size),
"page_size" => Ok(__FieldTag::__page_size),
"pageToken" => Ok(__FieldTag::__page_token),
"page_token" => Ok(__FieldTag::__page_token),
"offset" => Ok(__FieldTag::__offset),
"oneBoxPageSize" => Ok(__FieldTag::__one_box_page_size),
"one_box_page_size" => Ok(__FieldTag::__one_box_page_size),
"dataStoreSpecs" => Ok(__FieldTag::__data_store_specs),
"data_store_specs" => Ok(__FieldTag::__data_store_specs),
"filter" => Ok(__FieldTag::__filter),
"canonicalFilter" => Ok(__FieldTag::__canonical_filter),
"canonical_filter" => Ok(__FieldTag::__canonical_filter),
"orderBy" => Ok(__FieldTag::__order_by),
"order_by" => Ok(__FieldTag::__order_by),
"userInfo" => Ok(__FieldTag::__user_info),
"user_info" => Ok(__FieldTag::__user_info),
"languageCode" => Ok(__FieldTag::__language_code),
"language_code" => Ok(__FieldTag::__language_code),
"facetSpecs" => Ok(__FieldTag::__facet_specs),
"facet_specs" => Ok(__FieldTag::__facet_specs),
"boostSpec" => Ok(__FieldTag::__boost_spec),
"boost_spec" => Ok(__FieldTag::__boost_spec),
"params" => Ok(__FieldTag::__params),
"queryExpansionSpec" => Ok(__FieldTag::__query_expansion_spec),
"query_expansion_spec" => Ok(__FieldTag::__query_expansion_spec),
"spellCorrectionSpec" => Ok(__FieldTag::__spell_correction_spec),
"spell_correction_spec" => Ok(__FieldTag::__spell_correction_spec),
"userPseudoId" => Ok(__FieldTag::__user_pseudo_id),
"user_pseudo_id" => Ok(__FieldTag::__user_pseudo_id),
"contentSearchSpec" => Ok(__FieldTag::__content_search_spec),
"content_search_spec" => Ok(__FieldTag::__content_search_spec),
"rankingExpression" => Ok(__FieldTag::__ranking_expression),
"ranking_expression" => Ok(__FieldTag::__ranking_expression),
"rankingExpressionBackend" => {
Ok(__FieldTag::__ranking_expression_backend)
}
"ranking_expression_backend" => {
Ok(__FieldTag::__ranking_expression_backend)
}
"safeSearch" => Ok(__FieldTag::__safe_search),
"safe_search" => Ok(__FieldTag::__safe_search),
"userLabels" => Ok(__FieldTag::__user_labels),
"user_labels" => Ok(__FieldTag::__user_labels),
"naturalLanguageQueryUnderstandingSpec" => {
Ok(__FieldTag::__natural_language_query_understanding_spec)
}
"natural_language_query_understanding_spec" => {
Ok(__FieldTag::__natural_language_query_understanding_spec)
}
"searchAsYouTypeSpec" => Ok(__FieldTag::__search_as_you_type_spec),
"search_as_you_type_spec" => Ok(__FieldTag::__search_as_you_type_spec),
"displaySpec" => Ok(__FieldTag::__display_spec),
"display_spec" => Ok(__FieldTag::__display_spec),
"crowdingSpecs" => Ok(__FieldTag::__crowding_specs),
"crowding_specs" => Ok(__FieldTag::__crowding_specs),
"session" => Ok(__FieldTag::__session),
"sessionSpec" => Ok(__FieldTag::__session_spec),
"session_spec" => Ok(__FieldTag::__session_spec),
"relevanceThreshold" => Ok(__FieldTag::__relevance_threshold),
"relevance_threshold" => Ok(__FieldTag::__relevance_threshold),
"relevanceScoreSpec" => Ok(__FieldTag::__relevance_score_spec),
"relevance_score_spec" => Ok(__FieldTag::__relevance_score_spec),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::SearchRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SearchRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__serving_config => {
if !fields.insert(__FieldTag::__serving_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for serving_config",
));
}
result.serving_config = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__branch => {
if !fields.insert(__FieldTag::__branch) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for branch",
));
}
result.branch = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__query => {
if !fields.insert(__FieldTag::__query) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for query",
));
}
result.query = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__page_categories => {
if !fields.insert(__FieldTag::__page_categories) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_categories",
));
}
result.page_categories = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__image_query => {
if !fields.insert(__FieldTag::__image_query) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for image_query",
));
}
result.image_query = map.next_value::<std::option::Option<crate::model::search_request::ImageQuery>>()?
;
}
__FieldTag::__page_size => {
if !fields.insert(__FieldTag::__page_size) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_size",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.page_size = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__page_token => {
if !fields.insert(__FieldTag::__page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_token",
));
}
result.page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__offset => {
if !fields.insert(__FieldTag::__offset) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for offset",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.offset = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__one_box_page_size => {
if !fields.insert(__FieldTag::__one_box_page_size) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for one_box_page_size",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.one_box_page_size =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__data_store_specs => {
if !fields.insert(__FieldTag::__data_store_specs) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for data_store_specs",
));
}
result.data_store_specs = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::search_request::DataStoreSpec>,
>>()?
.unwrap_or_default();
}
__FieldTag::__filter => {
if !fields.insert(__FieldTag::__filter) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for filter",
));
}
result.filter = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__canonical_filter => {
if !fields.insert(__FieldTag::__canonical_filter) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for canonical_filter",
));
}
result.canonical_filter = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__order_by => {
if !fields.insert(__FieldTag::__order_by) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for order_by",
));
}
result.order_by = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__user_info => {
if !fields.insert(__FieldTag::__user_info) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for user_info",
));
}
result.user_info =
map.next_value::<std::option::Option<crate::model::UserInfo>>()?;
}
__FieldTag::__language_code => {
if !fields.insert(__FieldTag::__language_code) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for language_code",
));
}
result.language_code = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__facet_specs => {
if !fields.insert(__FieldTag::__facet_specs) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for facet_specs",
));
}
result.facet_specs = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::search_request::FacetSpec>,
>>()?
.unwrap_or_default();
}
__FieldTag::__boost_spec => {
if !fields.insert(__FieldTag::__boost_spec) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for boost_spec",
));
}
result.boost_spec = map.next_value::<std::option::Option<crate::model::search_request::BoostSpec>>()?
;
}
__FieldTag::__params => {
if !fields.insert(__FieldTag::__params) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for params",
));
}
result.params = map
.next_value::<std::option::Option<
std::collections::HashMap<std::string::String, wkt::Value>,
>>()?
.unwrap_or_default();
}
__FieldTag::__query_expansion_spec => {
if !fields.insert(__FieldTag::__query_expansion_spec) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for query_expansion_spec",
));
}
result.query_expansion_spec = map.next_value::<std::option::Option<
crate::model::search_request::QueryExpansionSpec,
>>()?;
}
__FieldTag::__spell_correction_spec => {
if !fields.insert(__FieldTag::__spell_correction_spec) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for spell_correction_spec",
));
}
result.spell_correction_spec = map.next_value::<std::option::Option<
crate::model::search_request::SpellCorrectionSpec,
>>()?;
}
__FieldTag::__user_pseudo_id => {
if !fields.insert(__FieldTag::__user_pseudo_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for user_pseudo_id",
));
}
result.user_pseudo_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__content_search_spec => {
if !fields.insert(__FieldTag::__content_search_spec) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for content_search_spec",
));
}
result.content_search_spec = map.next_value::<std::option::Option<
crate::model::search_request::ContentSearchSpec,
>>()?;
}
__FieldTag::__ranking_expression => {
if !fields.insert(__FieldTag::__ranking_expression) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for ranking_expression",
));
}
result.ranking_expression = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__ranking_expression_backend => {
if !fields.insert(__FieldTag::__ranking_expression_backend) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for ranking_expression_backend",
));
}
result.ranking_expression_backend = map
.next_value::<std::option::Option<
crate::model::search_request::RankingExpressionBackend,
>>()?
.unwrap_or_default();
}
__FieldTag::__safe_search => {
if !fields.insert(__FieldTag::__safe_search) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for safe_search",
));
}
result.safe_search = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__user_labels => {
if !fields.insert(__FieldTag::__user_labels) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for user_labels",
));
}
result.user_labels = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
std::string::String,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::__natural_language_query_understanding_spec => {
if !fields
.insert(__FieldTag::__natural_language_query_understanding_spec)
{
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for natural_language_query_understanding_spec",
));
}
result.natural_language_query_understanding_spec = map.next_value::<std::option::Option<crate::model::search_request::NaturalLanguageQueryUnderstandingSpec>>()?
;
}
__FieldTag::__search_as_you_type_spec => {
if !fields.insert(__FieldTag::__search_as_you_type_spec) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for search_as_you_type_spec",
));
}
result.search_as_you_type_spec = map.next_value::<std::option::Option<
crate::model::search_request::SearchAsYouTypeSpec,
>>()?;
}
__FieldTag::__display_spec => {
if !fields.insert(__FieldTag::__display_spec) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for display_spec",
));
}
result.display_spec = map.next_value::<std::option::Option<crate::model::search_request::DisplaySpec>>()?
;
}
__FieldTag::__crowding_specs => {
if !fields.insert(__FieldTag::__crowding_specs) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for crowding_specs",
));
}
result.crowding_specs = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::search_request::CrowdingSpec>,
>>()?
.unwrap_or_default();
}
__FieldTag::__session => {
if !fields.insert(__FieldTag::__session) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for session",
));
}
result.session = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__session_spec => {
if !fields.insert(__FieldTag::__session_spec) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for session_spec",
));
}
result.session_spec = map.next_value::<std::option::Option<crate::model::search_request::SessionSpec>>()?
;
}
__FieldTag::__relevance_threshold => {
if !fields.insert(__FieldTag::__relevance_threshold) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for relevance_threshold",
));
}
result.relevance_threshold = map
.next_value::<std::option::Option<
crate::model::search_request::RelevanceThreshold,
>>()?
.unwrap_or_default();
}
__FieldTag::__relevance_score_spec => {
if !fields.insert(__FieldTag::__relevance_score_spec) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for relevance_score_spec",
));
}
result.relevance_score_spec = map.next_value::<std::option::Option<
crate::model::search_request::RelevanceScoreSpec,
>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "assistant-service",
feature = "conversational-search-service",
feature = "search-service",
feature = "serving-config-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::search_request::ImageQuery {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__image_bytes,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ImageQuery")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"imageBytes" => Ok(__FieldTag::__image_bytes),
"image_bytes" => Ok(__FieldTag::__image_bytes),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_request::ImageQuery;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ImageQuery")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__image_bytes => {
if !fields.insert(__FieldTag::__image_bytes) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for image_bytes",
));
}
if result.image.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `image`, a oneof with full ID .google.cloud.discoveryengine.v1.SearchRequest.ImageQuery.image_bytes, latest field was imageBytes",
));
}
result.image = std::option::Option::Some(
crate::model::search_request::image_query::Image::ImageBytes(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "assistant-service",
feature = "conversational-search-service",
feature = "search-service",
feature = "serving-config-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::search_request::DataStoreSpec {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__data_store,
__filter,
__boost_spec,
__custom_search_operators,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DataStoreSpec")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"dataStore" => Ok(__FieldTag::__data_store),
"data_store" => Ok(__FieldTag::__data_store),
"filter" => Ok(__FieldTag::__filter),
"boostSpec" => Ok(__FieldTag::__boost_spec),
"boost_spec" => Ok(__FieldTag::__boost_spec),
"customSearchOperators" => Ok(__FieldTag::__custom_search_operators),
"custom_search_operators" => Ok(__FieldTag::__custom_search_operators),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_request::DataStoreSpec;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DataStoreSpec")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__data_store => {
if !fields.insert(__FieldTag::__data_store) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for data_store",
));
}
result.data_store = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__filter => {
if !fields.insert(__FieldTag::__filter) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for filter",
));
}
result.filter = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__boost_spec => {
if !fields.insert(__FieldTag::__boost_spec) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for boost_spec",
));
}
result.boost_spec = map.next_value::<std::option::Option<crate::model::search_request::BoostSpec>>()?
;
}
__FieldTag::__custom_search_operators => {
if !fields.insert(__FieldTag::__custom_search_operators) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for custom_search_operators",
));
}
result.custom_search_operators = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "assistant-service",
feature = "conversational-search-service",
feature = "search-service",
feature = "serving-config-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::search_request::FacetSpec {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__facet_key,
__limit,
__excluded_filter_keys,
__enable_dynamic_position,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for FacetSpec")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"facetKey" => Ok(__FieldTag::__facet_key),
"facet_key" => Ok(__FieldTag::__facet_key),
"limit" => Ok(__FieldTag::__limit),
"excludedFilterKeys" => Ok(__FieldTag::__excluded_filter_keys),
"excluded_filter_keys" => Ok(__FieldTag::__excluded_filter_keys),
"enableDynamicPosition" => Ok(__FieldTag::__enable_dynamic_position),
"enable_dynamic_position" => Ok(__FieldTag::__enable_dynamic_position),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_request::FacetSpec;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct FacetSpec")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__facet_key => {
if !fields.insert(__FieldTag::__facet_key) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for facet_key",
));
}
result.facet_key = map.next_value::<std::option::Option<
crate::model::search_request::facet_spec::FacetKey,
>>()?;
}
__FieldTag::__limit => {
if !fields.insert(__FieldTag::__limit) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for limit",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.limit = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__excluded_filter_keys => {
if !fields.insert(__FieldTag::__excluded_filter_keys) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for excluded_filter_keys",
));
}
result.excluded_filter_keys = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__enable_dynamic_position => {
if !fields.insert(__FieldTag::__enable_dynamic_position) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for enable_dynamic_position",
));
}
result.enable_dynamic_position = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "assistant-service",
feature = "conversational-search-service",
feature = "search-service",
feature = "serving-config-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::search_request::facet_spec::FacetKey {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__key,
__intervals,
__restricted_values,
__prefixes,
__contains,
__case_insensitive,
__order_by,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for FacetKey")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"key" => Ok(__FieldTag::__key),
"intervals" => Ok(__FieldTag::__intervals),
"restrictedValues" => Ok(__FieldTag::__restricted_values),
"restricted_values" => Ok(__FieldTag::__restricted_values),
"prefixes" => Ok(__FieldTag::__prefixes),
"contains" => Ok(__FieldTag::__contains),
"caseInsensitive" => Ok(__FieldTag::__case_insensitive),
"case_insensitive" => Ok(__FieldTag::__case_insensitive),
"orderBy" => Ok(__FieldTag::__order_by),
"order_by" => Ok(__FieldTag::__order_by),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_request::facet_spec::FacetKey;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct FacetKey")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__key => {
if !fields.insert(__FieldTag::__key) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for key",
));
}
result.key = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__intervals => {
if !fields.insert(__FieldTag::__intervals) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for intervals",
));
}
result.intervals = map.next_value::<std::option::Option<std::vec::Vec<crate::model::Interval>>>()?.unwrap_or_default();
}
__FieldTag::__restricted_values => {
if !fields.insert(__FieldTag::__restricted_values) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for restricted_values",
));
}
result.restricted_values = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__prefixes => {
if !fields.insert(__FieldTag::__prefixes) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for prefixes",
));
}
result.prefixes = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__contains => {
if !fields.insert(__FieldTag::__contains) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for contains",
));
}
result.contains = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__case_insensitive => {
if !fields.insert(__FieldTag::__case_insensitive) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for case_insensitive",
));
}
result.case_insensitive = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__order_by => {
if !fields.insert(__FieldTag::__order_by) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for order_by",
));
}
result.order_by = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "assistant-service",
feature = "conversational-search-service",
feature = "search-service",
feature = "serving-config-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::search_request::BoostSpec {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__condition_boost_specs,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for BoostSpec")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"conditionBoostSpecs" => Ok(__FieldTag::__condition_boost_specs),
"condition_boost_specs" => Ok(__FieldTag::__condition_boost_specs),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_request::BoostSpec;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BoostSpec")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__condition_boost_specs => {
if !fields.insert(__FieldTag::__condition_boost_specs) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for condition_boost_specs",
));
}
result.condition_boost_specs = map.next_value::<std::option::Option<std::vec::Vec<crate::model::search_request::boost_spec::ConditionBoostSpec>>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "assistant-service",
feature = "conversational-search-service",
feature = "search-service",
feature = "serving-config-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::search_request::boost_spec::ConditionBoostSpec {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__condition,
__boost,
__boost_control_spec,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ConditionBoostSpec")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"condition" => Ok(__FieldTag::__condition),
"boost" => Ok(__FieldTag::__boost),
"boostControlSpec" => Ok(__FieldTag::__boost_control_spec),
"boost_control_spec" => Ok(__FieldTag::__boost_control_spec),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_request::boost_spec::ConditionBoostSpec;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ConditionBoostSpec")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__condition => {
if !fields.insert(__FieldTag::__condition) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for condition",
));
}
result.condition = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__boost => {
if !fields.insert(__FieldTag::__boost) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for boost",
));
}
struct __With(std::option::Option<f32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F32> >::deserialize(deserializer).map(__With)
}
}
result.boost = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__boost_control_spec => {
if !fields.insert(__FieldTag::__boost_control_spec) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for boost_control_spec",
));
}
result.boost_control_spec = map.next_value::<std::option::Option<crate::model::search_request::boost_spec::condition_boost_spec::BoostControlSpec>>()?
;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "assistant-service",
feature = "conversational-search-service",
feature = "search-service",
feature = "serving-config-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::search_request::boost_spec::condition_boost_spec::BoostControlSpec
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__field_name,
__attribute_type,
__interpolation_type,
__control_points,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for BoostControlSpec")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"fieldName" => Ok(__FieldTag::__field_name),
"field_name" => Ok(__FieldTag::__field_name),
"attributeType" => Ok(__FieldTag::__attribute_type),
"attribute_type" => Ok(__FieldTag::__attribute_type),
"interpolationType" => Ok(__FieldTag::__interpolation_type),
"interpolation_type" => Ok(__FieldTag::__interpolation_type),
"controlPoints" => Ok(__FieldTag::__control_points),
"control_points" => Ok(__FieldTag::__control_points),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_request::boost_spec::condition_boost_spec::BoostControlSpec;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BoostControlSpec")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__field_name => {
if !fields.insert(__FieldTag::__field_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for field_name",
));
}
result.field_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__attribute_type => {
if !fields.insert(__FieldTag::__attribute_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for attribute_type",
));
}
result.attribute_type = map.next_value::<std::option::Option<crate::model::search_request::boost_spec::condition_boost_spec::boost_control_spec::AttributeType>>()?.unwrap_or_default();
}
__FieldTag::__interpolation_type => {
if !fields.insert(__FieldTag::__interpolation_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for interpolation_type",
));
}
result.interpolation_type = map.next_value::<std::option::Option<crate::model::search_request::boost_spec::condition_boost_spec::boost_control_spec::InterpolationType>>()?.unwrap_or_default();
}
__FieldTag::__control_points => {
if !fields.insert(__FieldTag::__control_points) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for control_points",
));
}
result.control_points = map.next_value::<std::option::Option<std::vec::Vec<crate::model::search_request::boost_spec::condition_boost_spec::boost_control_spec::ControlPoint>>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "assistant-service",
feature = "conversational-search-service",
feature = "search-service",
feature = "serving-config-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::search_request::boost_spec::condition_boost_spec::boost_control_spec::ControlPoint
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__attribute_value,
__boost_amount,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ControlPoint")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"attributeValue" => Ok(__FieldTag::__attribute_value),
"attribute_value" => Ok(__FieldTag::__attribute_value),
"boostAmount" => Ok(__FieldTag::__boost_amount),
"boost_amount" => Ok(__FieldTag::__boost_amount),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_request::boost_spec::condition_boost_spec::boost_control_spec::ControlPoint;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ControlPoint")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__attribute_value => {
if !fields.insert(__FieldTag::__attribute_value) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for attribute_value",
));
}
result.attribute_value = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__boost_amount => {
if !fields.insert(__FieldTag::__boost_amount) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for boost_amount",
));
}
struct __With(std::option::Option<f32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F32> >::deserialize(deserializer).map(__With)
}
}
result.boost_amount = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "assistant-service",
feature = "conversational-search-service",
feature = "search-service",
feature = "serving-config-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::search_request::QueryExpansionSpec {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__condition,
__pin_unexpanded_results,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for QueryExpansionSpec")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"condition" => Ok(__FieldTag::__condition),
"pinUnexpandedResults" => Ok(__FieldTag::__pin_unexpanded_results),
"pin_unexpanded_results" => Ok(__FieldTag::__pin_unexpanded_results),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_request::QueryExpansionSpec;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct QueryExpansionSpec")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__condition => {
if !fields.insert(__FieldTag::__condition) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for condition",
));
}
result.condition = map
.next_value::<std::option::Option<
crate::model::search_request::query_expansion_spec::Condition,
>>()?
.unwrap_or_default();
}
__FieldTag::__pin_unexpanded_results => {
if !fields.insert(__FieldTag::__pin_unexpanded_results) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for pin_unexpanded_results",
));
}
result.pin_unexpanded_results = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "assistant-service",
feature = "conversational-search-service",
feature = "search-service",
feature = "serving-config-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::search_request::SpellCorrectionSpec {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__mode,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SpellCorrectionSpec")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"mode" => Ok(__FieldTag::__mode),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_request::SpellCorrectionSpec;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SpellCorrectionSpec")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__mode => {
if !fields.insert(__FieldTag::__mode) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for mode",
));
}
result.mode = map
.next_value::<std::option::Option<
crate::model::search_request::spell_correction_spec::Mode,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "assistant-service",
feature = "conversational-search-service",
feature = "search-service",
feature = "serving-config-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::search_request::ContentSearchSpec {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__snippet_spec,
__summary_spec,
__extractive_content_spec,
__search_result_mode,
__chunk_spec,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ContentSearchSpec")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"snippetSpec" => Ok(__FieldTag::__snippet_spec),
"snippet_spec" => Ok(__FieldTag::__snippet_spec),
"summarySpec" => Ok(__FieldTag::__summary_spec),
"summary_spec" => Ok(__FieldTag::__summary_spec),
"extractiveContentSpec" => Ok(__FieldTag::__extractive_content_spec),
"extractive_content_spec" => Ok(__FieldTag::__extractive_content_spec),
"searchResultMode" => Ok(__FieldTag::__search_result_mode),
"search_result_mode" => Ok(__FieldTag::__search_result_mode),
"chunkSpec" => Ok(__FieldTag::__chunk_spec),
"chunk_spec" => Ok(__FieldTag::__chunk_spec),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_request::ContentSearchSpec;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ContentSearchSpec")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__snippet_spec => {
if !fields.insert(__FieldTag::__snippet_spec) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for snippet_spec",
));
}
result.snippet_spec = map.next_value::<std::option::Option<
crate::model::search_request::content_search_spec::SnippetSpec,
>>()?;
}
__FieldTag::__summary_spec => {
if !fields.insert(__FieldTag::__summary_spec) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for summary_spec",
));
}
result.summary_spec = map.next_value::<std::option::Option<
crate::model::search_request::content_search_spec::SummarySpec,
>>()?;
}
__FieldTag::__extractive_content_spec => {
if !fields.insert(__FieldTag::__extractive_content_spec) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for extractive_content_spec",
));
}
result.extractive_content_spec = map.next_value::<std::option::Option<crate::model::search_request::content_search_spec::ExtractiveContentSpec>>()?
;
}
__FieldTag::__search_result_mode => {
if !fields.insert(__FieldTag::__search_result_mode) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for search_result_mode",
));
}
result.search_result_mode = map.next_value::<std::option::Option<crate::model::search_request::content_search_spec::SearchResultMode>>()?.unwrap_or_default();
}
__FieldTag::__chunk_spec => {
if !fields.insert(__FieldTag::__chunk_spec) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for chunk_spec",
));
}
result.chunk_spec = map.next_value::<std::option::Option<
crate::model::search_request::content_search_spec::ChunkSpec,
>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "assistant-service",
feature = "conversational-search-service",
feature = "search-service",
feature = "serving-config-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::search_request::content_search_spec::SnippetSpec {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__max_snippet_count,
__reference_only,
__return_snippet,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SnippetSpec")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"maxSnippetCount" => Ok(__FieldTag::__max_snippet_count),
"max_snippet_count" => Ok(__FieldTag::__max_snippet_count),
"referenceOnly" => Ok(__FieldTag::__reference_only),
"reference_only" => Ok(__FieldTag::__reference_only),
"returnSnippet" => Ok(__FieldTag::__return_snippet),
"return_snippet" => Ok(__FieldTag::__return_snippet),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_request::content_search_spec::SnippetSpec;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SnippetSpec")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__max_snippet_count => {
if !fields.insert(__FieldTag::__max_snippet_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for max_snippet_count",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.max_snippet_count =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__reference_only => {
if !fields.insert(__FieldTag::__reference_only) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for reference_only",
));
}
result.reference_only = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__return_snippet => {
if !fields.insert(__FieldTag::__return_snippet) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for return_snippet",
));
}
result.return_snippet = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "assistant-service",
feature = "conversational-search-service",
feature = "search-service",
feature = "serving-config-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::search_request::content_search_spec::SummarySpec {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__summary_result_count,
__include_citations,
__ignore_adversarial_query,
__ignore_non_summary_seeking_query,
__ignore_low_relevant_content,
__ignore_jail_breaking_query,
__model_prompt_spec,
__language_code,
__model_spec,
__use_semantic_chunks,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SummarySpec")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"summaryResultCount" => Ok(__FieldTag::__summary_result_count),
"summary_result_count" => Ok(__FieldTag::__summary_result_count),
"includeCitations" => Ok(__FieldTag::__include_citations),
"include_citations" => Ok(__FieldTag::__include_citations),
"ignoreAdversarialQuery" => Ok(__FieldTag::__ignore_adversarial_query),
"ignore_adversarial_query" => {
Ok(__FieldTag::__ignore_adversarial_query)
}
"ignoreNonSummarySeekingQuery" => {
Ok(__FieldTag::__ignore_non_summary_seeking_query)
}
"ignore_non_summary_seeking_query" => {
Ok(__FieldTag::__ignore_non_summary_seeking_query)
}
"ignoreLowRelevantContent" => {
Ok(__FieldTag::__ignore_low_relevant_content)
}
"ignore_low_relevant_content" => {
Ok(__FieldTag::__ignore_low_relevant_content)
}
"ignoreJailBreakingQuery" => {
Ok(__FieldTag::__ignore_jail_breaking_query)
}
"ignore_jail_breaking_query" => {
Ok(__FieldTag::__ignore_jail_breaking_query)
}
"modelPromptSpec" => Ok(__FieldTag::__model_prompt_spec),
"model_prompt_spec" => Ok(__FieldTag::__model_prompt_spec),
"languageCode" => Ok(__FieldTag::__language_code),
"language_code" => Ok(__FieldTag::__language_code),
"modelSpec" => Ok(__FieldTag::__model_spec),
"model_spec" => Ok(__FieldTag::__model_spec),
"useSemanticChunks" => Ok(__FieldTag::__use_semantic_chunks),
"use_semantic_chunks" => Ok(__FieldTag::__use_semantic_chunks),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_request::content_search_spec::SummarySpec;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SummarySpec")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__summary_result_count => {
if !fields.insert(__FieldTag::__summary_result_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for summary_result_count",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.summary_result_count =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__include_citations => {
if !fields.insert(__FieldTag::__include_citations) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for include_citations",
));
}
result.include_citations = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__ignore_adversarial_query => {
if !fields.insert(__FieldTag::__ignore_adversarial_query) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for ignore_adversarial_query",
));
}
result.ignore_adversarial_query = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__ignore_non_summary_seeking_query => {
if !fields.insert(__FieldTag::__ignore_non_summary_seeking_query) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for ignore_non_summary_seeking_query",
));
}
result.ignore_non_summary_seeking_query = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__ignore_low_relevant_content => {
if !fields.insert(__FieldTag::__ignore_low_relevant_content) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for ignore_low_relevant_content",
));
}
result.ignore_low_relevant_content = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__ignore_jail_breaking_query => {
if !fields.insert(__FieldTag::__ignore_jail_breaking_query) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for ignore_jail_breaking_query",
));
}
result.ignore_jail_breaking_query = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__model_prompt_spec => {
if !fields.insert(__FieldTag::__model_prompt_spec) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for model_prompt_spec",
));
}
result.model_prompt_spec = map.next_value::<std::option::Option<crate::model::search_request::content_search_spec::summary_spec::ModelPromptSpec>>()?
;
}
__FieldTag::__language_code => {
if !fields.insert(__FieldTag::__language_code) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for language_code",
));
}
result.language_code = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__model_spec => {
if !fields.insert(__FieldTag::__model_spec) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for model_spec",
));
}
result.model_spec = map.next_value::<std::option::Option<crate::model::search_request::content_search_spec::summary_spec::ModelSpec>>()?
;
}
__FieldTag::__use_semantic_chunks => {
if !fields.insert(__FieldTag::__use_semantic_chunks) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for use_semantic_chunks",
));
}
result.use_semantic_chunks = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "assistant-service",
feature = "conversational-search-service",
feature = "search-service",
feature = "serving-config-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::search_request::content_search_spec::summary_spec::ModelPromptSpec
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__preamble,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ModelPromptSpec")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"preamble" => Ok(__FieldTag::__preamble),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_request::content_search_spec::summary_spec::ModelPromptSpec;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ModelPromptSpec")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__preamble => {
if !fields.insert(__FieldTag::__preamble) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for preamble",
));
}
result.preamble = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "assistant-service",
feature = "conversational-search-service",
feature = "search-service",
feature = "serving-config-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::search_request::content_search_spec::summary_spec::ModelSpec
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__version,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ModelSpec")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"version" => Ok(__FieldTag::__version),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_request::content_search_spec::summary_spec::ModelSpec;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ModelSpec")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__version => {
if !fields.insert(__FieldTag::__version) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for version",
));
}
result.version = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "assistant-service",
feature = "conversational-search-service",
feature = "search-service",
feature = "serving-config-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::search_request::content_search_spec::ExtractiveContentSpec
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__max_extractive_answer_count,
__max_extractive_segment_count,
__return_extractive_segment_score,
__num_previous_segments,
__num_next_segments,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ExtractiveContentSpec")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"maxExtractiveAnswerCount" => {
Ok(__FieldTag::__max_extractive_answer_count)
}
"max_extractive_answer_count" => {
Ok(__FieldTag::__max_extractive_answer_count)
}
"maxExtractiveSegmentCount" => {
Ok(__FieldTag::__max_extractive_segment_count)
}
"max_extractive_segment_count" => {
Ok(__FieldTag::__max_extractive_segment_count)
}
"returnExtractiveSegmentScore" => {
Ok(__FieldTag::__return_extractive_segment_score)
}
"return_extractive_segment_score" => {
Ok(__FieldTag::__return_extractive_segment_score)
}
"numPreviousSegments" => Ok(__FieldTag::__num_previous_segments),
"num_previous_segments" => Ok(__FieldTag::__num_previous_segments),
"numNextSegments" => Ok(__FieldTag::__num_next_segments),
"num_next_segments" => Ok(__FieldTag::__num_next_segments),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_request::content_search_spec::ExtractiveContentSpec;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ExtractiveContentSpec")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__max_extractive_answer_count => {
if !fields.insert(__FieldTag::__max_extractive_answer_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for max_extractive_answer_count",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.max_extractive_answer_count =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__max_extractive_segment_count => {
if !fields.insert(__FieldTag::__max_extractive_segment_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for max_extractive_segment_count",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.max_extractive_segment_count =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__return_extractive_segment_score => {
if !fields.insert(__FieldTag::__return_extractive_segment_score) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for return_extractive_segment_score",
));
}
result.return_extractive_segment_score = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__num_previous_segments => {
if !fields.insert(__FieldTag::__num_previous_segments) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for num_previous_segments",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.num_previous_segments =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__num_next_segments => {
if !fields.insert(__FieldTag::__num_next_segments) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for num_next_segments",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.num_next_segments =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "assistant-service",
feature = "conversational-search-service",
feature = "search-service",
feature = "serving-config-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::search_request::content_search_spec::ChunkSpec {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__num_previous_chunks,
__num_next_chunks,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ChunkSpec")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"numPreviousChunks" => Ok(__FieldTag::__num_previous_chunks),
"num_previous_chunks" => Ok(__FieldTag::__num_previous_chunks),
"numNextChunks" => Ok(__FieldTag::__num_next_chunks),
"num_next_chunks" => Ok(__FieldTag::__num_next_chunks),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_request::content_search_spec::ChunkSpec;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ChunkSpec")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__num_previous_chunks => {
if !fields.insert(__FieldTag::__num_previous_chunks) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for num_previous_chunks",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.num_previous_chunks =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__num_next_chunks => {
if !fields.insert(__FieldTag::__num_next_chunks) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for num_next_chunks",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.num_next_chunks =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "assistant-service",
feature = "conversational-search-service",
feature = "search-service",
feature = "serving-config-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::search_request::NaturalLanguageQueryUnderstandingSpec
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__filter_extraction_condition,
__geo_search_query_detection_field_names,
__extracted_filter_behavior,
__allowed_field_names,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter
.write_str("a field name for NaturalLanguageQueryUnderstandingSpec")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"filterExtractionCondition" => {
Ok(__FieldTag::__filter_extraction_condition)
}
"filter_extraction_condition" => {
Ok(__FieldTag::__filter_extraction_condition)
}
"geoSearchQueryDetectionFieldNames" => {
Ok(__FieldTag::__geo_search_query_detection_field_names)
}
"geo_search_query_detection_field_names" => {
Ok(__FieldTag::__geo_search_query_detection_field_names)
}
"extractedFilterBehavior" => {
Ok(__FieldTag::__extracted_filter_behavior)
}
"extracted_filter_behavior" => {
Ok(__FieldTag::__extracted_filter_behavior)
}
"allowedFieldNames" => Ok(__FieldTag::__allowed_field_names),
"allowed_field_names" => Ok(__FieldTag::__allowed_field_names),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_request::NaturalLanguageQueryUnderstandingSpec;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct NaturalLanguageQueryUnderstandingSpec")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__filter_extraction_condition => {
if !fields.insert(__FieldTag::__filter_extraction_condition) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for filter_extraction_condition",
));
}
result.filter_extraction_condition = map.next_value::<std::option::Option<crate::model::search_request::natural_language_query_understanding_spec::FilterExtractionCondition>>()?.unwrap_or_default();
}
__FieldTag::__geo_search_query_detection_field_names => {
if !fields.insert(__FieldTag::__geo_search_query_detection_field_names)
{
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for geo_search_query_detection_field_names",
));
}
result.geo_search_query_detection_field_names = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__extracted_filter_behavior => {
if !fields.insert(__FieldTag::__extracted_filter_behavior) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for extracted_filter_behavior",
));
}
result.extracted_filter_behavior = map.next_value::<std::option::Option<crate::model::search_request::natural_language_query_understanding_spec::ExtractedFilterBehavior>>()?.unwrap_or_default();
}
__FieldTag::__allowed_field_names => {
if !fields.insert(__FieldTag::__allowed_field_names) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for allowed_field_names",
));
}
result.allowed_field_names = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "assistant-service",
feature = "conversational-search-service",
feature = "search-service",
feature = "serving-config-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::search_request::SearchAsYouTypeSpec {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__condition,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SearchAsYouTypeSpec")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"condition" => Ok(__FieldTag::__condition),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_request::SearchAsYouTypeSpec;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SearchAsYouTypeSpec")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__condition => {
if !fields.insert(__FieldTag::__condition) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for condition",
));
}
result.condition = map.next_value::<std::option::Option<crate::model::search_request::search_as_you_type_spec::Condition>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "assistant-service",
feature = "conversational-search-service",
feature = "search-service",
feature = "serving-config-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::search_request::DisplaySpec {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__match_highlighting_condition,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DisplaySpec")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"matchHighlightingCondition" => {
Ok(__FieldTag::__match_highlighting_condition)
}
"match_highlighting_condition" => {
Ok(__FieldTag::__match_highlighting_condition)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_request::DisplaySpec;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DisplaySpec")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__match_highlighting_condition => {
if !fields.insert(__FieldTag::__match_highlighting_condition) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for match_highlighting_condition",
));
}
result.match_highlighting_condition = map.next_value::<std::option::Option<crate::model::search_request::display_spec::MatchHighlightingCondition>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "assistant-service",
feature = "conversational-search-service",
feature = "search-service",
feature = "serving-config-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::search_request::CrowdingSpec {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__field,
__max_count,
__mode,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for CrowdingSpec")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"field" => Ok(__FieldTag::__field),
"maxCount" => Ok(__FieldTag::__max_count),
"max_count" => Ok(__FieldTag::__max_count),
"mode" => Ok(__FieldTag::__mode),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_request::CrowdingSpec;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CrowdingSpec")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__field => {
if !fields.insert(__FieldTag::__field) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for field",
));
}
result.field = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__max_count => {
if !fields.insert(__FieldTag::__max_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for max_count",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.max_count = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__mode => {
if !fields.insert(__FieldTag::__mode) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for mode",
));
}
result.mode = map
.next_value::<std::option::Option<
crate::model::search_request::crowding_spec::Mode,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "assistant-service",
feature = "conversational-search-service",
feature = "search-service",
feature = "serving-config-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::search_request::SessionSpec {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__query_id,
__search_result_persistence_count,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SessionSpec")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"queryId" => Ok(__FieldTag::__query_id),
"query_id" => Ok(__FieldTag::__query_id),
"searchResultPersistenceCount" => {
Ok(__FieldTag::__search_result_persistence_count)
}
"search_result_persistence_count" => {
Ok(__FieldTag::__search_result_persistence_count)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_request::SessionSpec;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SessionSpec")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__query_id => {
if !fields.insert(__FieldTag::__query_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for query_id",
));
}
result.query_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__search_result_persistence_count => {
if !fields.insert(__FieldTag::__search_result_persistence_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for search_result_persistence_count",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.search_result_persistence_count = map.next_value::<__With>()?.0;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "assistant-service",
feature = "conversational-search-service",
feature = "search-service",
feature = "serving-config-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::search_request::RelevanceScoreSpec {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__return_relevance_score,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for RelevanceScoreSpec")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"returnRelevanceScore" => Ok(__FieldTag::__return_relevance_score),
"return_relevance_score" => Ok(__FieldTag::__return_relevance_score),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_request::RelevanceScoreSpec;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct RelevanceScoreSpec")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__return_relevance_score => {
if !fields.insert(__FieldTag::__return_relevance_score) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for return_relevance_score",
));
}
result.return_relevance_score = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::SearchResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__results,
__facets,
__total_size,
__attribution_token,
__redirect_uri,
__next_page_token,
__corrected_query,
__summary,
__query_expansion_info,
__natural_language_query_understanding_info,
__session_info,
__search_link_promotions,
__semantic_state,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SearchResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"results" => Ok(__FieldTag::__results),
"facets" => Ok(__FieldTag::__facets),
"totalSize" => Ok(__FieldTag::__total_size),
"total_size" => Ok(__FieldTag::__total_size),
"attributionToken" => Ok(__FieldTag::__attribution_token),
"attribution_token" => Ok(__FieldTag::__attribution_token),
"redirectUri" => Ok(__FieldTag::__redirect_uri),
"redirect_uri" => Ok(__FieldTag::__redirect_uri),
"nextPageToken" => Ok(__FieldTag::__next_page_token),
"next_page_token" => Ok(__FieldTag::__next_page_token),
"correctedQuery" => Ok(__FieldTag::__corrected_query),
"corrected_query" => Ok(__FieldTag::__corrected_query),
"summary" => Ok(__FieldTag::__summary),
"queryExpansionInfo" => Ok(__FieldTag::__query_expansion_info),
"query_expansion_info" => Ok(__FieldTag::__query_expansion_info),
"naturalLanguageQueryUnderstandingInfo" => {
Ok(__FieldTag::__natural_language_query_understanding_info)
}
"natural_language_query_understanding_info" => {
Ok(__FieldTag::__natural_language_query_understanding_info)
}
"sessionInfo" => Ok(__FieldTag::__session_info),
"session_info" => Ok(__FieldTag::__session_info),
"searchLinkPromotions" => Ok(__FieldTag::__search_link_promotions),
"search_link_promotions" => Ok(__FieldTag::__search_link_promotions),
"semanticState" => Ok(__FieldTag::__semantic_state),
"semantic_state" => Ok(__FieldTag::__semantic_state),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::SearchResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SearchResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__results => {
if !fields.insert(__FieldTag::__results) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for results",
));
}
result.results = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::search_response::SearchResult>,
>>()?
.unwrap_or_default();
}
__FieldTag::__facets => {
if !fields.insert(__FieldTag::__facets) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for facets",
));
}
result.facets = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::search_response::Facet>,
>>()?
.unwrap_or_default();
}
__FieldTag::__total_size => {
if !fields.insert(__FieldTag::__total_size) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for total_size",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.total_size = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__attribution_token => {
if !fields.insert(__FieldTag::__attribution_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for attribution_token",
));
}
result.attribution_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__redirect_uri => {
if !fields.insert(__FieldTag::__redirect_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for redirect_uri",
));
}
result.redirect_uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__next_page_token => {
if !fields.insert(__FieldTag::__next_page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for next_page_token",
));
}
result.next_page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__corrected_query => {
if !fields.insert(__FieldTag::__corrected_query) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for corrected_query",
));
}
result.corrected_query = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__summary => {
if !fields.insert(__FieldTag::__summary) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for summary",
));
}
result.summary = map.next_value::<std::option::Option<crate::model::search_response::Summary>>()?
;
}
__FieldTag::__query_expansion_info => {
if !fields.insert(__FieldTag::__query_expansion_info) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for query_expansion_info",
));
}
result.query_expansion_info = map.next_value::<std::option::Option<
crate::model::search_response::QueryExpansionInfo,
>>()?;
}
__FieldTag::__natural_language_query_understanding_info => {
if !fields
.insert(__FieldTag::__natural_language_query_understanding_info)
{
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for natural_language_query_understanding_info",
));
}
result.natural_language_query_understanding_info = map.next_value::<std::option::Option<crate::model::search_response::NaturalLanguageQueryUnderstandingInfo>>()?
;
}
__FieldTag::__session_info => {
if !fields.insert(__FieldTag::__session_info) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for session_info",
));
}
result.session_info = map.next_value::<std::option::Option<crate::model::search_response::SessionInfo>>()?
;
}
__FieldTag::__search_link_promotions => {
if !fields.insert(__FieldTag::__search_link_promotions) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for search_link_promotions",
));
}
result.search_link_promotions = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::SearchLinkPromotion>,
>>()?
.unwrap_or_default();
}
__FieldTag::__semantic_state => {
if !fields.insert(__FieldTag::__semantic_state) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for semantic_state",
));
}
result.semantic_state =
map.next_value::<std::option::Option<
crate::model::search_response::SemanticState,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::search_response::SearchResult {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__id,
__document,
__chunk,
__model_scores,
__rank_signals,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SearchResult")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"id" => Ok(__FieldTag::__id),
"document" => Ok(__FieldTag::__document),
"chunk" => Ok(__FieldTag::__chunk),
"modelScores" => Ok(__FieldTag::__model_scores),
"model_scores" => Ok(__FieldTag::__model_scores),
"rankSignals" => Ok(__FieldTag::__rank_signals),
"rank_signals" => Ok(__FieldTag::__rank_signals),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_response::SearchResult;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SearchResult")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__id => {
if !fields.insert(__FieldTag::__id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for id",
));
}
result.id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__document => {
if !fields.insert(__FieldTag::__document) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for document",
));
}
result.document =
map.next_value::<std::option::Option<crate::model::Document>>()?;
}
__FieldTag::__chunk => {
if !fields.insert(__FieldTag::__chunk) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for chunk",
));
}
result.chunk =
map.next_value::<std::option::Option<crate::model::Chunk>>()?;
}
__FieldTag::__model_scores => {
if !fields.insert(__FieldTag::__model_scores) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for model_scores",
));
}
result.model_scores = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
crate::model::DoubleList,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::__rank_signals => {
if !fields.insert(__FieldTag::__rank_signals) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for rank_signals",
));
}
result.rank_signals = map.next_value::<std::option::Option<
crate::model::search_response::search_result::RankSignals,
>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::search_response::search_result::RankSignals {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__keyword_similarity_score,
__relevance_score,
__semantic_similarity_score,
__pctr_rank,
__topicality_rank,
__document_age,
__boosting_factor,
__default_rank,
__custom_signals,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for RankSignals")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"keywordSimilarityScore" => Ok(__FieldTag::__keyword_similarity_score),
"keyword_similarity_score" => {
Ok(__FieldTag::__keyword_similarity_score)
}
"relevanceScore" => Ok(__FieldTag::__relevance_score),
"relevance_score" => Ok(__FieldTag::__relevance_score),
"semanticSimilarityScore" => {
Ok(__FieldTag::__semantic_similarity_score)
}
"semantic_similarity_score" => {
Ok(__FieldTag::__semantic_similarity_score)
}
"pctrRank" => Ok(__FieldTag::__pctr_rank),
"pctr_rank" => Ok(__FieldTag::__pctr_rank),
"topicalityRank" => Ok(__FieldTag::__topicality_rank),
"topicality_rank" => Ok(__FieldTag::__topicality_rank),
"documentAge" => Ok(__FieldTag::__document_age),
"document_age" => Ok(__FieldTag::__document_age),
"boostingFactor" => Ok(__FieldTag::__boosting_factor),
"boosting_factor" => Ok(__FieldTag::__boosting_factor),
"defaultRank" => Ok(__FieldTag::__default_rank),
"default_rank" => Ok(__FieldTag::__default_rank),
"customSignals" => Ok(__FieldTag::__custom_signals),
"custom_signals" => Ok(__FieldTag::__custom_signals),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_response::search_result::RankSignals;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct RankSignals")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__keyword_similarity_score => {
if !fields.insert(__FieldTag::__keyword_similarity_score) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for keyword_similarity_score",
));
}
struct __With(std::option::Option<f32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F32> >::deserialize(deserializer).map(__With)
}
}
result.keyword_similarity_score = map.next_value::<__With>()?.0;
}
__FieldTag::__relevance_score => {
if !fields.insert(__FieldTag::__relevance_score) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for relevance_score",
));
}
struct __With(std::option::Option<f32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F32> >::deserialize(deserializer).map(__With)
}
}
result.relevance_score = map.next_value::<__With>()?.0;
}
__FieldTag::__semantic_similarity_score => {
if !fields.insert(__FieldTag::__semantic_similarity_score) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for semantic_similarity_score",
));
}
struct __With(std::option::Option<f32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F32> >::deserialize(deserializer).map(__With)
}
}
result.semantic_similarity_score = map.next_value::<__With>()?.0;
}
__FieldTag::__pctr_rank => {
if !fields.insert(__FieldTag::__pctr_rank) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for pctr_rank",
));
}
struct __With(std::option::Option<f32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F32> >::deserialize(deserializer).map(__With)
}
}
result.pctr_rank = map.next_value::<__With>()?.0;
}
__FieldTag::__topicality_rank => {
if !fields.insert(__FieldTag::__topicality_rank) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for topicality_rank",
));
}
struct __With(std::option::Option<f32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F32> >::deserialize(deserializer).map(__With)
}
}
result.topicality_rank = map.next_value::<__With>()?.0;
}
__FieldTag::__document_age => {
if !fields.insert(__FieldTag::__document_age) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for document_age",
));
}
struct __With(std::option::Option<f32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F32> >::deserialize(deserializer).map(__With)
}
}
result.document_age = map.next_value::<__With>()?.0;
}
__FieldTag::__boosting_factor => {
if !fields.insert(__FieldTag::__boosting_factor) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for boosting_factor",
));
}
struct __With(std::option::Option<f32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F32> >::deserialize(deserializer).map(__With)
}
}
result.boosting_factor = map.next_value::<__With>()?.0;
}
__FieldTag::__default_rank => {
if !fields.insert(__FieldTag::__default_rank) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for default_rank",
));
}
struct __With(std::option::Option<f32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F32> >::deserialize(deserializer).map(__With)
}
}
result.default_rank = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__custom_signals => {
if !fields.insert(__FieldTag::__custom_signals) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for custom_signals",
));
}
result.custom_signals = map.next_value::<std::option::Option<std::vec::Vec<crate::model::search_response::search_result::rank_signals::CustomSignal>>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::search_response::search_result::rank_signals::CustomSignal
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
__value,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for CustomSignal")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
"value" => Ok(__FieldTag::__value),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_response::search_result::rank_signals::CustomSignal;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CustomSignal")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__value => {
if !fields.insert(__FieldTag::__value) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for value",
));
}
struct __With(std::option::Option<f32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F32> >::deserialize(deserializer).map(__With)
}
}
result.value = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::search_response::Facet {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__key,
__values,
__dynamic_facet,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Facet")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"key" => Ok(__FieldTag::__key),
"values" => Ok(__FieldTag::__values),
"dynamicFacet" => Ok(__FieldTag::__dynamic_facet),
"dynamic_facet" => Ok(__FieldTag::__dynamic_facet),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_response::Facet;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Facet")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__key => {
if !fields.insert(__FieldTag::__key) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for key",
));
}
result.key = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__values => {
if !fields.insert(__FieldTag::__values) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for values",
));
}
result.values = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::search_response::facet::FacetValue>,
>>()?
.unwrap_or_default();
}
__FieldTag::__dynamic_facet => {
if !fields.insert(__FieldTag::__dynamic_facet) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for dynamic_facet",
));
}
result.dynamic_facet = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::search_response::facet::FacetValue {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__value,
__interval,
__count,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for FacetValue")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"value" => Ok(__FieldTag::__value),
"interval" => Ok(__FieldTag::__interval),
"count" => Ok(__FieldTag::__count),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_response::facet::FacetValue;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct FacetValue")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__value => {
if !fields.insert(__FieldTag::__value) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for value",
));
}
if result.facet_value.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `facet_value`, a oneof with full ID .google.cloud.discoveryengine.v1.SearchResponse.Facet.FacetValue.value, latest field was value",
));
}
result.facet_value = std::option::Option::Some(
crate::model::search_response::facet::facet_value::FacetValue::Value(
map.next_value::<std::option::Option<std::string::String>>()?.unwrap_or_default()
),
);
}
__FieldTag::__interval => {
if !fields.insert(__FieldTag::__interval) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for interval",
));
}
if result.facet_value.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `facet_value`, a oneof with full ID .google.cloud.discoveryengine.v1.SearchResponse.Facet.FacetValue.interval, latest field was interval",
));
}
result.facet_value = std::option::Option::Some(
crate::model::search_response::facet::facet_value::FacetValue::Interval(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::Interval>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__count => {
if !fields.insert(__FieldTag::__count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for count",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.count = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::search_response::Summary {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__summary_text,
__summary_skipped_reasons,
__safety_attributes,
__summary_with_metadata,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Summary")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"summaryText" => Ok(__FieldTag::__summary_text),
"summary_text" => Ok(__FieldTag::__summary_text),
"summarySkippedReasons" => Ok(__FieldTag::__summary_skipped_reasons),
"summary_skipped_reasons" => Ok(__FieldTag::__summary_skipped_reasons),
"safetyAttributes" => Ok(__FieldTag::__safety_attributes),
"safety_attributes" => Ok(__FieldTag::__safety_attributes),
"summaryWithMetadata" => Ok(__FieldTag::__summary_with_metadata),
"summary_with_metadata" => Ok(__FieldTag::__summary_with_metadata),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_response::Summary;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Summary")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__summary_text => {
if !fields.insert(__FieldTag::__summary_text) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for summary_text",
));
}
result.summary_text = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__summary_skipped_reasons => {
if !fields.insert(__FieldTag::__summary_skipped_reasons) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for summary_skipped_reasons",
));
}
result.summary_skipped_reasons = map.next_value::<std::option::Option<std::vec::Vec<crate::model::search_response::summary::SummarySkippedReason>>>()?.unwrap_or_default();
}
__FieldTag::__safety_attributes => {
if !fields.insert(__FieldTag::__safety_attributes) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for safety_attributes",
));
}
result.safety_attributes = map.next_value::<std::option::Option<
crate::model::search_response::summary::SafetyAttributes,
>>()?;
}
__FieldTag::__summary_with_metadata => {
if !fields.insert(__FieldTag::__summary_with_metadata) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for summary_with_metadata",
));
}
result.summary_with_metadata = map.next_value::<std::option::Option<
crate::model::search_response::summary::SummaryWithMetadata,
>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::search_response::summary::SafetyAttributes {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__categories,
__scores,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SafetyAttributes")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"categories" => Ok(__FieldTag::__categories),
"scores" => Ok(__FieldTag::__scores),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_response::summary::SafetyAttributes;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SafetyAttributes")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__categories => {
if !fields.insert(__FieldTag::__categories) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for categories",
));
}
result.categories = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__scores => {
if !fields.insert(__FieldTag::__scores) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for scores",
));
}
struct __With(std::option::Option<std::vec::Vec<f32>>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::<
std::option::Option<std::vec::Vec<wkt::internal::F32>>,
>::deserialize(deserializer)
.map(__With)
}
}
result.scores = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::search_response::summary::CitationMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__citations,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for CitationMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"citations" => Ok(__FieldTag::__citations),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_response::summary::CitationMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CitationMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__citations => {
if !fields.insert(__FieldTag::__citations) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for citations",
));
}
result.citations = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::search_response::summary::Citation>,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::search_response::summary::Citation {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__start_index,
__end_index,
__sources,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Citation")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"startIndex" => Ok(__FieldTag::__start_index),
"start_index" => Ok(__FieldTag::__start_index),
"endIndex" => Ok(__FieldTag::__end_index),
"end_index" => Ok(__FieldTag::__end_index),
"sources" => Ok(__FieldTag::__sources),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_response::summary::Citation;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Citation")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__start_index => {
if !fields.insert(__FieldTag::__start_index) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for start_index",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.start_index = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__end_index => {
if !fields.insert(__FieldTag::__end_index) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for end_index",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.end_index = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__sources => {
if !fields.insert(__FieldTag::__sources) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for sources",
));
}
result.sources = map
.next_value::<std::option::Option<
std::vec::Vec<
crate::model::search_response::summary::CitationSource,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::search_response::summary::CitationSource {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__reference_index,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for CitationSource")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"referenceIndex" => Ok(__FieldTag::__reference_index),
"reference_index" => Ok(__FieldTag::__reference_index),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_response::summary::CitationSource;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CitationSource")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__reference_index => {
if !fields.insert(__FieldTag::__reference_index) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for reference_index",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.reference_index =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::search_response::summary::Reference {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__title,
__document,
__uri,
__chunk_contents,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Reference")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"title" => Ok(__FieldTag::__title),
"document" => Ok(__FieldTag::__document),
"uri" => Ok(__FieldTag::__uri),
"chunkContents" => Ok(__FieldTag::__chunk_contents),
"chunk_contents" => Ok(__FieldTag::__chunk_contents),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_response::summary::Reference;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Reference")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__title => {
if !fields.insert(__FieldTag::__title) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for title",
));
}
result.title = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__document => {
if !fields.insert(__FieldTag::__document) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for document",
));
}
result.document = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__uri => {
if !fields.insert(__FieldTag::__uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for uri",
));
}
result.uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__chunk_contents => {
if !fields.insert(__FieldTag::__chunk_contents) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for chunk_contents",
));
}
result.chunk_contents = map.next_value::<std::option::Option<std::vec::Vec<crate::model::search_response::summary::reference::ChunkContent>>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::search_response::summary::reference::ChunkContent {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__content,
__page_identifier,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ChunkContent")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"content" => Ok(__FieldTag::__content),
"pageIdentifier" => Ok(__FieldTag::__page_identifier),
"page_identifier" => Ok(__FieldTag::__page_identifier),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_response::summary::reference::ChunkContent;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ChunkContent")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__content => {
if !fields.insert(__FieldTag::__content) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for content",
));
}
result.content = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__page_identifier => {
if !fields.insert(__FieldTag::__page_identifier) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_identifier",
));
}
result.page_identifier = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::search_response::summary::SummaryWithMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__summary,
__citation_metadata,
__references,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SummaryWithMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"summary" => Ok(__FieldTag::__summary),
"citationMetadata" => Ok(__FieldTag::__citation_metadata),
"citation_metadata" => Ok(__FieldTag::__citation_metadata),
"references" => Ok(__FieldTag::__references),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_response::summary::SummaryWithMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SummaryWithMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__summary => {
if !fields.insert(__FieldTag::__summary) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for summary",
));
}
result.summary = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__citation_metadata => {
if !fields.insert(__FieldTag::__citation_metadata) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for citation_metadata",
));
}
result.citation_metadata = map.next_value::<std::option::Option<
crate::model::search_response::summary::CitationMetadata,
>>()?;
}
__FieldTag::__references => {
if !fields.insert(__FieldTag::__references) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for references",
));
}
result.references = map
.next_value::<std::option::Option<
std::vec::Vec<
crate::model::search_response::summary::Reference,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::search_response::QueryExpansionInfo {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__expanded_query,
__pinned_result_count,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for QueryExpansionInfo")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"expandedQuery" => Ok(__FieldTag::__expanded_query),
"expanded_query" => Ok(__FieldTag::__expanded_query),
"pinnedResultCount" => Ok(__FieldTag::__pinned_result_count),
"pinned_result_count" => Ok(__FieldTag::__pinned_result_count),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_response::QueryExpansionInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct QueryExpansionInfo")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__expanded_query => {
if !fields.insert(__FieldTag::__expanded_query) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for expanded_query",
));
}
result.expanded_query = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__pinned_result_count => {
if !fields.insert(__FieldTag::__pinned_result_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for pinned_result_count",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.pinned_result_count =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::search_response::NaturalLanguageQueryUnderstandingInfo
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__extracted_filters,
__rewritten_query,
__classified_intents,
__structured_extracted_filter,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter
.write_str("a field name for NaturalLanguageQueryUnderstandingInfo")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"extractedFilters" => Ok(__FieldTag::__extracted_filters),
"extracted_filters" => Ok(__FieldTag::__extracted_filters),
"rewrittenQuery" => Ok(__FieldTag::__rewritten_query),
"rewritten_query" => Ok(__FieldTag::__rewritten_query),
"classifiedIntents" => Ok(__FieldTag::__classified_intents),
"classified_intents" => Ok(__FieldTag::__classified_intents),
"structuredExtractedFilter" => {
Ok(__FieldTag::__structured_extracted_filter)
}
"structured_extracted_filter" => {
Ok(__FieldTag::__structured_extracted_filter)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_response::NaturalLanguageQueryUnderstandingInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct NaturalLanguageQueryUnderstandingInfo")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__extracted_filters => {
if !fields.insert(__FieldTag::__extracted_filters) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for extracted_filters",
));
}
result.extracted_filters = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__rewritten_query => {
if !fields.insert(__FieldTag::__rewritten_query) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for rewritten_query",
));
}
result.rewritten_query = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__classified_intents => {
if !fields.insert(__FieldTag::__classified_intents) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for classified_intents",
));
}
result.classified_intents = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__structured_extracted_filter => {
if !fields.insert(__FieldTag::__structured_extracted_filter) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for structured_extracted_filter",
));
}
result.structured_extracted_filter = map.next_value::<std::option::Option<crate::model::search_response::natural_language_query_understanding_info::StructuredExtractedFilter>>()?
;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::search_response::natural_language_query_understanding_info::StructuredExtractedFilter
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__expression,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for StructuredExtractedFilter")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"expression" => Ok(__FieldTag::__expression),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_response::natural_language_query_understanding_info::StructuredExtractedFilter;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct StructuredExtractedFilter")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__expression => {
if !fields.insert(__FieldTag::__expression) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for expression",
));
}
result.expression = map.next_value::<std::option::Option<crate::model::search_response::natural_language_query_understanding_info::structured_extracted_filter::Expression>>()?
;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::search_response::natural_language_query_understanding_info::structured_extracted_filter::StringConstraint {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__field_name,
__values,
__query_segment,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for StringConstraint")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"fieldName" => Ok(__FieldTag::__field_name),
"field_name" => Ok(__FieldTag::__field_name),
"values" => Ok(__FieldTag::__values),
"querySegment" => Ok(__FieldTag::__query_segment),
"query_segment" => Ok(__FieldTag::__query_segment),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_response::natural_language_query_understanding_info::structured_extracted_filter::StringConstraint;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct StringConstraint")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
use std::option::Option::Some;
#[allow(unused_imports)]
use serde::de::Error;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__field_name => {
if !fields.insert(__FieldTag::__field_name) {
return std::result::Result::Err(A::Error::duplicate_field("multiple values for field_name"));
}
result.field_name = map.next_value::<std::option::Option<std::string::String>>()?.unwrap_or_default();
},
__FieldTag::__values => {
if !fields.insert(__FieldTag::__values) {
return std::result::Result::Err(A::Error::duplicate_field("multiple values for values"));
}
result.values = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
},
__FieldTag::__query_segment => {
if !fields.insert(__FieldTag::__query_segment) {
return std::result::Result::Err(A::Error::duplicate_field("multiple values for query_segment"));
}
result.query_segment = map.next_value::<std::option::Option<std::string::String>>()?.unwrap_or_default();
},
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
},
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::search_response::natural_language_query_understanding_info::structured_extracted_filter::NumberConstraint {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__field_name,
__comparison,
__value,
__query_segment,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for NumberConstraint")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"fieldName" => Ok(__FieldTag::__field_name),
"field_name" => Ok(__FieldTag::__field_name),
"comparison" => Ok(__FieldTag::__comparison),
"value" => Ok(__FieldTag::__value),
"querySegment" => Ok(__FieldTag::__query_segment),
"query_segment" => Ok(__FieldTag::__query_segment),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_response::natural_language_query_understanding_info::structured_extracted_filter::NumberConstraint;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct NumberConstraint")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
use std::option::Option::Some;
#[allow(unused_imports)]
use serde::de::Error;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__field_name => {
if !fields.insert(__FieldTag::__field_name) {
return std::result::Result::Err(A::Error::duplicate_field("multiple values for field_name"));
}
result.field_name = map.next_value::<std::option::Option<std::string::String>>()?.unwrap_or_default();
},
__FieldTag::__comparison => {
if !fields.insert(__FieldTag::__comparison) {
return std::result::Result::Err(A::Error::duplicate_field("multiple values for comparison"));
}
result.comparison = map.next_value::<std::option::Option<crate::model::search_response::natural_language_query_understanding_info::structured_extracted_filter::number_constraint::Comparison>>()?.unwrap_or_default();
},
__FieldTag::__value => {
if !fields.insert(__FieldTag::__value) {
return std::result::Result::Err(A::Error::duplicate_field("multiple values for value"));
}
struct __With( std::option::Option<f64> );
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F64> >::deserialize(deserializer).map(__With)
}
}
result.value = map.next_value::< __With >()?.0.unwrap_or_default();
},
__FieldTag::__query_segment => {
if !fields.insert(__FieldTag::__query_segment) {
return std::result::Result::Err(A::Error::duplicate_field("multiple values for query_segment"));
}
result.query_segment = map.next_value::<std::option::Option<std::string::String>>()?.unwrap_or_default();
},
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
},
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::search_response::natural_language_query_understanding_info::structured_extracted_filter::GeolocationConstraint {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__field_name,
__address,
__latitude,
__longitude,
__radius_in_meters,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for GeolocationConstraint")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"fieldName" => Ok(__FieldTag::__field_name),
"field_name" => Ok(__FieldTag::__field_name),
"address" => Ok(__FieldTag::__address),
"latitude" => Ok(__FieldTag::__latitude),
"longitude" => Ok(__FieldTag::__longitude),
"radiusInMeters" => Ok(__FieldTag::__radius_in_meters),
"radius_in_meters" => Ok(__FieldTag::__radius_in_meters),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_response::natural_language_query_understanding_info::structured_extracted_filter::GeolocationConstraint;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GeolocationConstraint")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
use std::option::Option::Some;
#[allow(unused_imports)]
use serde::de::Error;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__field_name => {
if !fields.insert(__FieldTag::__field_name) {
return std::result::Result::Err(A::Error::duplicate_field("multiple values for field_name"));
}
result.field_name = map.next_value::<std::option::Option<std::string::String>>()?.unwrap_or_default();
},
__FieldTag::__address => {
if !fields.insert(__FieldTag::__address) {
return std::result::Result::Err(A::Error::duplicate_field("multiple values for address"));
}
result.address = map.next_value::<std::option::Option<std::string::String>>()?.unwrap_or_default();
},
__FieldTag::__latitude => {
if !fields.insert(__FieldTag::__latitude) {
return std::result::Result::Err(A::Error::duplicate_field("multiple values for latitude"));
}
struct __With( std::option::Option<f64> );
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F64> >::deserialize(deserializer).map(__With)
}
}
result.latitude = map.next_value::< __With >()?.0.unwrap_or_default();
},
__FieldTag::__longitude => {
if !fields.insert(__FieldTag::__longitude) {
return std::result::Result::Err(A::Error::duplicate_field("multiple values for longitude"));
}
struct __With( std::option::Option<f64> );
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F64> >::deserialize(deserializer).map(__With)
}
}
result.longitude = map.next_value::< __With >()?.0.unwrap_or_default();
},
__FieldTag::__radius_in_meters => {
if !fields.insert(__FieldTag::__radius_in_meters) {
return std::result::Result::Err(A::Error::duplicate_field("multiple values for radius_in_meters"));
}
struct __With( std::option::Option<f32> );
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F32> >::deserialize(deserializer).map(__With)
}
}
result.radius_in_meters = map.next_value::< __With >()?.0.unwrap_or_default();
},
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
},
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::search_response::natural_language_query_understanding_info::structured_extracted_filter::AndExpression {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__expressions,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for AndExpression")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"expressions" => Ok(__FieldTag::__expressions),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_response::natural_language_query_understanding_info::structured_extracted_filter::AndExpression;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct AndExpression")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
use std::option::Option::Some;
#[allow(unused_imports)]
use serde::de::Error;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__expressions => {
if !fields.insert(__FieldTag::__expressions) {
return std::result::Result::Err(A::Error::duplicate_field("multiple values for expressions"));
}
result.expressions = map.next_value::<std::option::Option<std::vec::Vec<crate::model::search_response::natural_language_query_understanding_info::structured_extracted_filter::Expression>>>()?.unwrap_or_default();
},
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
},
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::search_response::natural_language_query_understanding_info::structured_extracted_filter::OrExpression {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__expressions,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for OrExpression")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"expressions" => Ok(__FieldTag::__expressions),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_response::natural_language_query_understanding_info::structured_extracted_filter::OrExpression;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct OrExpression")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
use std::option::Option::Some;
#[allow(unused_imports)]
use serde::de::Error;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__expressions => {
if !fields.insert(__FieldTag::__expressions) {
return std::result::Result::Err(A::Error::duplicate_field("multiple values for expressions"));
}
result.expressions = map.next_value::<std::option::Option<std::vec::Vec<crate::model::search_response::natural_language_query_understanding_info::structured_extracted_filter::Expression>>>()?.unwrap_or_default();
},
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
},
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::search_response::natural_language_query_understanding_info::structured_extracted_filter::Expression {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__string_constraint,
__number_constraint,
__geolocation_constraint,
__and_expr,
__or_expr,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Expression")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"stringConstraint" => Ok(__FieldTag::__string_constraint),
"string_constraint" => Ok(__FieldTag::__string_constraint),
"numberConstraint" => Ok(__FieldTag::__number_constraint),
"number_constraint" => Ok(__FieldTag::__number_constraint),
"geolocationConstraint" => Ok(__FieldTag::__geolocation_constraint),
"geolocation_constraint" => Ok(__FieldTag::__geolocation_constraint),
"andExpr" => Ok(__FieldTag::__and_expr),
"and_expr" => Ok(__FieldTag::__and_expr),
"orExpr" => Ok(__FieldTag::__or_expr),
"or_expr" => Ok(__FieldTag::__or_expr),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_response::natural_language_query_understanding_info::structured_extracted_filter::Expression;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Expression")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
use std::option::Option::Some;
#[allow(unused_imports)]
use serde::de::Error;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__string_constraint => {
if !fields.insert(__FieldTag::__string_constraint) {
return std::result::Result::Err(A::Error::duplicate_field("multiple values for string_constraint"));
}
if result.expr.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `expr`, a oneof with full ID .google.cloud.discoveryengine.v1.SearchResponse.NaturalLanguageQueryUnderstandingInfo.StructuredExtractedFilter.Expression.string_constraint, latest field was stringConstraint",
));
}
result.expr = std::option::Option::Some(
crate::model::search_response::natural_language_query_understanding_info::structured_extracted_filter::expression::Expr::StringConstraint(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::search_response::natural_language_query_understanding_info::structured_extracted_filter::StringConstraint>>>()?.unwrap_or_default()
),
);
},
__FieldTag::__number_constraint => {
if !fields.insert(__FieldTag::__number_constraint) {
return std::result::Result::Err(A::Error::duplicate_field("multiple values for number_constraint"));
}
if result.expr.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `expr`, a oneof with full ID .google.cloud.discoveryengine.v1.SearchResponse.NaturalLanguageQueryUnderstandingInfo.StructuredExtractedFilter.Expression.number_constraint, latest field was numberConstraint",
));
}
result.expr = std::option::Option::Some(
crate::model::search_response::natural_language_query_understanding_info::structured_extracted_filter::expression::Expr::NumberConstraint(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::search_response::natural_language_query_understanding_info::structured_extracted_filter::NumberConstraint>>>()?.unwrap_or_default()
),
);
},
__FieldTag::__geolocation_constraint => {
if !fields.insert(__FieldTag::__geolocation_constraint) {
return std::result::Result::Err(A::Error::duplicate_field("multiple values for geolocation_constraint"));
}
if result.expr.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `expr`, a oneof with full ID .google.cloud.discoveryengine.v1.SearchResponse.NaturalLanguageQueryUnderstandingInfo.StructuredExtractedFilter.Expression.geolocation_constraint, latest field was geolocationConstraint",
));
}
result.expr = std::option::Option::Some(
crate::model::search_response::natural_language_query_understanding_info::structured_extracted_filter::expression::Expr::GeolocationConstraint(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::search_response::natural_language_query_understanding_info::structured_extracted_filter::GeolocationConstraint>>>()?.unwrap_or_default()
),
);
},
__FieldTag::__and_expr => {
if !fields.insert(__FieldTag::__and_expr) {
return std::result::Result::Err(A::Error::duplicate_field("multiple values for and_expr"));
}
if result.expr.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `expr`, a oneof with full ID .google.cloud.discoveryengine.v1.SearchResponse.NaturalLanguageQueryUnderstandingInfo.StructuredExtractedFilter.Expression.and_expr, latest field was andExpr",
));
}
result.expr = std::option::Option::Some(
crate::model::search_response::natural_language_query_understanding_info::structured_extracted_filter::expression::Expr::AndExpr(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::search_response::natural_language_query_understanding_info::structured_extracted_filter::AndExpression>>>()?.unwrap_or_default()
),
);
},
__FieldTag::__or_expr => {
if !fields.insert(__FieldTag::__or_expr) {
return std::result::Result::Err(A::Error::duplicate_field("multiple values for or_expr"));
}
if result.expr.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `expr`, a oneof with full ID .google.cloud.discoveryengine.v1.SearchResponse.NaturalLanguageQueryUnderstandingInfo.StructuredExtractedFilter.Expression.or_expr, latest field was orExpr",
));
}
result.expr = std::option::Option::Some(
crate::model::search_response::natural_language_query_understanding_info::structured_extracted_filter::expression::Expr::OrExpr(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::search_response::natural_language_query_understanding_info::structured_extracted_filter::OrExpression>>>()?.unwrap_or_default()
),
);
},
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
},
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "search-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::search_response::SessionInfo {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
__query_id,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SessionInfo")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
"queryId" => Ok(__FieldTag::__query_id),
"query_id" => Ok(__FieldTag::__query_id),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::search_response::SessionInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SessionInfo")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__query_id => {
if !fields.insert(__FieldTag::__query_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for query_id",
));
}
result.query_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "search-tuning-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ListCustomModelsRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__data_store,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ListCustomModelsRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"dataStore" => Ok(__FieldTag::__data_store),
"data_store" => Ok(__FieldTag::__data_store),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListCustomModelsRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListCustomModelsRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__data_store => {
if !fields.insert(__FieldTag::__data_store) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for data_store",
));
}
result.data_store = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "search-tuning-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ListCustomModelsResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__models,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ListCustomModelsResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"models" => Ok(__FieldTag::__models),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListCustomModelsResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListCustomModelsResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__models => {
if !fields.insert(__FieldTag::__models) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for models",
));
}
result.models =
map.next_value::<std::option::Option<
std::vec::Vec<crate::model::CustomTuningModel>,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "search-tuning-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::TrainCustomModelRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__gcs_training_input,
__data_store,
__model_type,
__error_config,
__model_id,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for TrainCustomModelRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"gcsTrainingInput" => Ok(__FieldTag::__gcs_training_input),
"gcs_training_input" => Ok(__FieldTag::__gcs_training_input),
"dataStore" => Ok(__FieldTag::__data_store),
"data_store" => Ok(__FieldTag::__data_store),
"modelType" => Ok(__FieldTag::__model_type),
"model_type" => Ok(__FieldTag::__model_type),
"errorConfig" => Ok(__FieldTag::__error_config),
"error_config" => Ok(__FieldTag::__error_config),
"modelId" => Ok(__FieldTag::__model_id),
"model_id" => Ok(__FieldTag::__model_id),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::TrainCustomModelRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct TrainCustomModelRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__gcs_training_input => {
if !fields.insert(__FieldTag::__gcs_training_input) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for gcs_training_input",
));
}
if result.training_input.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `training_input`, a oneof with full ID .google.cloud.discoveryengine.v1.TrainCustomModelRequest.gcs_training_input, latest field was gcsTrainingInput",
));
}
result.training_input = std::option::Option::Some(
crate::model::train_custom_model_request::TrainingInput::GcsTrainingInput(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::train_custom_model_request::GcsTrainingInput>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__data_store => {
if !fields.insert(__FieldTag::__data_store) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for data_store",
));
}
result.data_store = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__model_type => {
if !fields.insert(__FieldTag::__model_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for model_type",
));
}
result.model_type = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__error_config => {
if !fields.insert(__FieldTag::__error_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for error_config",
));
}
result.error_config = map
.next_value::<std::option::Option<crate::model::ImportErrorConfig>>(
)?;
}
__FieldTag::__model_id => {
if !fields.insert(__FieldTag::__model_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for model_id",
));
}
result.model_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "search-tuning-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::train_custom_model_request::GcsTrainingInput {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__corpus_data_path,
__query_data_path,
__train_data_path,
__test_data_path,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for GcsTrainingInput")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"corpusDataPath" => Ok(__FieldTag::__corpus_data_path),
"corpus_data_path" => Ok(__FieldTag::__corpus_data_path),
"queryDataPath" => Ok(__FieldTag::__query_data_path),
"query_data_path" => Ok(__FieldTag::__query_data_path),
"trainDataPath" => Ok(__FieldTag::__train_data_path),
"train_data_path" => Ok(__FieldTag::__train_data_path),
"testDataPath" => Ok(__FieldTag::__test_data_path),
"test_data_path" => Ok(__FieldTag::__test_data_path),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::train_custom_model_request::GcsTrainingInput;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GcsTrainingInput")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__corpus_data_path => {
if !fields.insert(__FieldTag::__corpus_data_path) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for corpus_data_path",
));
}
result.corpus_data_path = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__query_data_path => {
if !fields.insert(__FieldTag::__query_data_path) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for query_data_path",
));
}
result.query_data_path = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__train_data_path => {
if !fields.insert(__FieldTag::__train_data_path) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for train_data_path",
));
}
result.train_data_path = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__test_data_path => {
if !fields.insert(__FieldTag::__test_data_path) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for test_data_path",
));
}
result.test_data_path = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "search-tuning-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::TrainCustomModelResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__error_samples,
__error_config,
__model_status,
__metrics,
__model_name,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for TrainCustomModelResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"errorSamples" => Ok(__FieldTag::__error_samples),
"error_samples" => Ok(__FieldTag::__error_samples),
"errorConfig" => Ok(__FieldTag::__error_config),
"error_config" => Ok(__FieldTag::__error_config),
"modelStatus" => Ok(__FieldTag::__model_status),
"model_status" => Ok(__FieldTag::__model_status),
"metrics" => Ok(__FieldTag::__metrics),
"modelName" => Ok(__FieldTag::__model_name),
"model_name" => Ok(__FieldTag::__model_name),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::TrainCustomModelResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct TrainCustomModelResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__error_samples => {
if !fields.insert(__FieldTag::__error_samples) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for error_samples",
));
}
result.error_samples =
map.next_value::<std::option::Option<
std::vec::Vec<google_cloud_rpc::model::Status>,
>>()?
.unwrap_or_default();
}
__FieldTag::__error_config => {
if !fields.insert(__FieldTag::__error_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for error_config",
));
}
result.error_config = map
.next_value::<std::option::Option<crate::model::ImportErrorConfig>>(
)?;
}
__FieldTag::__model_status => {
if !fields.insert(__FieldTag::__model_status) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for model_status",
));
}
result.model_status = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__metrics => {
if !fields.insert(__FieldTag::__metrics) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for metrics",
));
}
struct __With(
std::option::Option<
std::collections::HashMap<std::string::String, f64>,
>,
);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::<
std::option::Option<
std::collections::HashMap<
serde_with::Same,
wkt::internal::F64,
>,
>,
>::deserialize(deserializer)
.map(__With)
}
}
result.metrics = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__model_name => {
if !fields.insert(__FieldTag::__model_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for model_name",
));
}
result.model_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "search-tuning-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::TrainCustomModelMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__create_time,
__update_time,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for TrainCustomModelMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"updateTime" => Ok(__FieldTag::__update_time),
"update_time" => Ok(__FieldTag::__update_time),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::TrainCustomModelMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct TrainCustomModelMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__update_time => {
if !fields.insert(__FieldTag::__update_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_time",
));
}
result.update_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "serving-config-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ServingConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__media_config,
__generic_config,
__name,
__display_name,
__solution_type,
__model_id,
__diversity_level,
__ranking_expression,
__create_time,
__update_time,
__filter_control_ids,
__boost_control_ids,
__redirect_control_ids,
__synonyms_control_ids,
__oneway_synonyms_control_ids,
__dissociate_control_ids,
__replacement_control_ids,
__ignore_control_ids,
__promote_control_ids,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ServingConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"mediaConfig" => Ok(__FieldTag::__media_config),
"media_config" => Ok(__FieldTag::__media_config),
"genericConfig" => Ok(__FieldTag::__generic_config),
"generic_config" => Ok(__FieldTag::__generic_config),
"name" => Ok(__FieldTag::__name),
"displayName" => Ok(__FieldTag::__display_name),
"display_name" => Ok(__FieldTag::__display_name),
"solutionType" => Ok(__FieldTag::__solution_type),
"solution_type" => Ok(__FieldTag::__solution_type),
"modelId" => Ok(__FieldTag::__model_id),
"model_id" => Ok(__FieldTag::__model_id),
"diversityLevel" => Ok(__FieldTag::__diversity_level),
"diversity_level" => Ok(__FieldTag::__diversity_level),
"rankingExpression" => Ok(__FieldTag::__ranking_expression),
"ranking_expression" => Ok(__FieldTag::__ranking_expression),
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"updateTime" => Ok(__FieldTag::__update_time),
"update_time" => Ok(__FieldTag::__update_time),
"filterControlIds" => Ok(__FieldTag::__filter_control_ids),
"filter_control_ids" => Ok(__FieldTag::__filter_control_ids),
"boostControlIds" => Ok(__FieldTag::__boost_control_ids),
"boost_control_ids" => Ok(__FieldTag::__boost_control_ids),
"redirectControlIds" => Ok(__FieldTag::__redirect_control_ids),
"redirect_control_ids" => Ok(__FieldTag::__redirect_control_ids),
"synonymsControlIds" => Ok(__FieldTag::__synonyms_control_ids),
"synonyms_control_ids" => Ok(__FieldTag::__synonyms_control_ids),
"onewaySynonymsControlIds" => {
Ok(__FieldTag::__oneway_synonyms_control_ids)
}
"oneway_synonyms_control_ids" => {
Ok(__FieldTag::__oneway_synonyms_control_ids)
}
"dissociateControlIds" => Ok(__FieldTag::__dissociate_control_ids),
"dissociate_control_ids" => Ok(__FieldTag::__dissociate_control_ids),
"replacementControlIds" => Ok(__FieldTag::__replacement_control_ids),
"replacement_control_ids" => Ok(__FieldTag::__replacement_control_ids),
"ignoreControlIds" => Ok(__FieldTag::__ignore_control_ids),
"ignore_control_ids" => Ok(__FieldTag::__ignore_control_ids),
"promoteControlIds" => Ok(__FieldTag::__promote_control_ids),
"promote_control_ids" => Ok(__FieldTag::__promote_control_ids),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ServingConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ServingConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__media_config => {
if !fields.insert(__FieldTag::__media_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for media_config",
));
}
if result.vertical_config.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `vertical_config`, a oneof with full ID .google.cloud.discoveryengine.v1.ServingConfig.media_config, latest field was mediaConfig",
));
}
result.vertical_config = std::option::Option::Some(
crate::model::serving_config::VerticalConfig::MediaConfig(
map.next_value::<std::option::Option<
std::boxed::Box<crate::model::serving_config::MediaConfig>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__generic_config => {
if !fields.insert(__FieldTag::__generic_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for generic_config",
));
}
if result.vertical_config.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `vertical_config`, a oneof with full ID .google.cloud.discoveryengine.v1.ServingConfig.generic_config, latest field was genericConfig",
));
}
result.vertical_config = std::option::Option::Some(
crate::model::serving_config::VerticalConfig::GenericConfig(
map.next_value::<std::option::Option<
std::boxed::Box<
crate::model::serving_config::GenericConfig,
>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__display_name => {
if !fields.insert(__FieldTag::__display_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for display_name",
));
}
result.display_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__solution_type => {
if !fields.insert(__FieldTag::__solution_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for solution_type",
));
}
result.solution_type = map
.next_value::<std::option::Option<crate::model::SolutionType>>()?
.unwrap_or_default();
}
__FieldTag::__model_id => {
if !fields.insert(__FieldTag::__model_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for model_id",
));
}
result.model_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__diversity_level => {
if !fields.insert(__FieldTag::__diversity_level) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for diversity_level",
));
}
result.diversity_level = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__ranking_expression => {
if !fields.insert(__FieldTag::__ranking_expression) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for ranking_expression",
));
}
result.ranking_expression = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__update_time => {
if !fields.insert(__FieldTag::__update_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_time",
));
}
result.update_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__filter_control_ids => {
if !fields.insert(__FieldTag::__filter_control_ids) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for filter_control_ids",
));
}
result.filter_control_ids = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__boost_control_ids => {
if !fields.insert(__FieldTag::__boost_control_ids) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for boost_control_ids",
));
}
result.boost_control_ids = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__redirect_control_ids => {
if !fields.insert(__FieldTag::__redirect_control_ids) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for redirect_control_ids",
));
}
result.redirect_control_ids = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__synonyms_control_ids => {
if !fields.insert(__FieldTag::__synonyms_control_ids) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for synonyms_control_ids",
));
}
result.synonyms_control_ids = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__oneway_synonyms_control_ids => {
if !fields.insert(__FieldTag::__oneway_synonyms_control_ids) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for oneway_synonyms_control_ids",
));
}
result.oneway_synonyms_control_ids = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__dissociate_control_ids => {
if !fields.insert(__FieldTag::__dissociate_control_ids) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for dissociate_control_ids",
));
}
result.dissociate_control_ids = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__replacement_control_ids => {
if !fields.insert(__FieldTag::__replacement_control_ids) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for replacement_control_ids",
));
}
result.replacement_control_ids = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__ignore_control_ids => {
if !fields.insert(__FieldTag::__ignore_control_ids) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for ignore_control_ids",
));
}
result.ignore_control_ids = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__promote_control_ids => {
if !fields.insert(__FieldTag::__promote_control_ids) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for promote_control_ids",
));
}
result.promote_control_ids = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "serving-config-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::serving_config::MediaConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__content_watched_percentage_threshold,
__content_watched_seconds_threshold,
__demotion_event_type,
__demote_content_watched_past_days,
__content_freshness_cutoff_days,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for MediaConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"contentWatchedPercentageThreshold" => {
Ok(__FieldTag::__content_watched_percentage_threshold)
}
"content_watched_percentage_threshold" => {
Ok(__FieldTag::__content_watched_percentage_threshold)
}
"contentWatchedSecondsThreshold" => {
Ok(__FieldTag::__content_watched_seconds_threshold)
}
"content_watched_seconds_threshold" => {
Ok(__FieldTag::__content_watched_seconds_threshold)
}
"demotionEventType" => Ok(__FieldTag::__demotion_event_type),
"demotion_event_type" => Ok(__FieldTag::__demotion_event_type),
"demoteContentWatchedPastDays" => {
Ok(__FieldTag::__demote_content_watched_past_days)
}
"demote_content_watched_past_days" => {
Ok(__FieldTag::__demote_content_watched_past_days)
}
"contentFreshnessCutoffDays" => {
Ok(__FieldTag::__content_freshness_cutoff_days)
}
"content_freshness_cutoff_days" => {
Ok(__FieldTag::__content_freshness_cutoff_days)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::serving_config::MediaConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct MediaConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__content_watched_percentage_threshold => {
if !fields.insert(__FieldTag::__content_watched_percentage_threshold) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for content_watched_percentage_threshold",
));
}
struct __With(std::option::Option<f32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F32> >::deserialize(deserializer).map(__With)
}
}
if result.demote_content_watched.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `demote_content_watched`, a oneof with full ID .google.cloud.discoveryengine.v1.ServingConfig.MediaConfig.content_watched_percentage_threshold, latest field was contentWatchedPercentageThreshold",
));
}
result.demote_content_watched = std::option::Option::Some(
crate::model::serving_config::media_config::DemoteContentWatched::ContentWatchedPercentageThreshold(
map.next_value::<__With>()?.0.unwrap_or_default()
),
);
}
__FieldTag::__content_watched_seconds_threshold => {
if !fields.insert(__FieldTag::__content_watched_seconds_threshold) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for content_watched_seconds_threshold",
));
}
struct __With(std::option::Option<f32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F32> >::deserialize(deserializer).map(__With)
}
}
if result.demote_content_watched.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `demote_content_watched`, a oneof with full ID .google.cloud.discoveryengine.v1.ServingConfig.MediaConfig.content_watched_seconds_threshold, latest field was contentWatchedSecondsThreshold",
));
}
result.demote_content_watched = std::option::Option::Some(
crate::model::serving_config::media_config::DemoteContentWatched::ContentWatchedSecondsThreshold(
map.next_value::<__With>()?.0.unwrap_or_default()
),
);
}
__FieldTag::__demotion_event_type => {
if !fields.insert(__FieldTag::__demotion_event_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for demotion_event_type",
));
}
result.demotion_event_type = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__demote_content_watched_past_days => {
if !fields.insert(__FieldTag::__demote_content_watched_past_days) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for demote_content_watched_past_days",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.demote_content_watched_past_days =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__content_freshness_cutoff_days => {
if !fields.insert(__FieldTag::__content_freshness_cutoff_days) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for content_freshness_cutoff_days",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.content_freshness_cutoff_days =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "serving-config-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::serving_config::GenericConfig {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__content_search_spec,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for GenericConfig")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"contentSearchSpec" => Ok(__FieldTag::__content_search_spec),
"content_search_spec" => Ok(__FieldTag::__content_search_spec),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::serving_config::GenericConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GenericConfig")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__content_search_spec => {
if !fields.insert(__FieldTag::__content_search_spec) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for content_search_spec",
));
}
result.content_search_spec = map.next_value::<std::option::Option<
crate::model::search_request::ContentSearchSpec,
>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "serving-config-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::UpdateServingConfigRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__serving_config,
__update_mask,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for UpdateServingConfigRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"servingConfig" => Ok(__FieldTag::__serving_config),
"serving_config" => Ok(__FieldTag::__serving_config),
"updateMask" => Ok(__FieldTag::__update_mask),
"update_mask" => Ok(__FieldTag::__update_mask),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::UpdateServingConfigRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct UpdateServingConfigRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__serving_config => {
if !fields.insert(__FieldTag::__serving_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for serving_config",
));
}
result.serving_config = map
.next_value::<std::option::Option<crate::model::ServingConfig>>()?;
}
__FieldTag::__update_mask => {
if !fields.insert(__FieldTag::__update_mask) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_mask",
));
}
result.update_mask =
map.next_value::<std::option::Option<wkt::FieldMask>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::Session {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
__display_name,
__state,
__user_pseudo_id,
__turns,
__labels,
__start_time,
__end_time,
__is_pinned,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Session")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
"displayName" => Ok(__FieldTag::__display_name),
"display_name" => Ok(__FieldTag::__display_name),
"state" => Ok(__FieldTag::__state),
"userPseudoId" => Ok(__FieldTag::__user_pseudo_id),
"user_pseudo_id" => Ok(__FieldTag::__user_pseudo_id),
"turns" => Ok(__FieldTag::__turns),
"labels" => Ok(__FieldTag::__labels),
"startTime" => Ok(__FieldTag::__start_time),
"start_time" => Ok(__FieldTag::__start_time),
"endTime" => Ok(__FieldTag::__end_time),
"end_time" => Ok(__FieldTag::__end_time),
"isPinned" => Ok(__FieldTag::__is_pinned),
"is_pinned" => Ok(__FieldTag::__is_pinned),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Session;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Session")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__display_name => {
if !fields.insert(__FieldTag::__display_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for display_name",
));
}
result.display_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__state => {
if !fields.insert(__FieldTag::__state) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for state",
));
}
result.state = map
.next_value::<std::option::Option<crate::model::session::State>>()?
.unwrap_or_default();
}
__FieldTag::__user_pseudo_id => {
if !fields.insert(__FieldTag::__user_pseudo_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for user_pseudo_id",
));
}
result.user_pseudo_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__turns => {
if !fields.insert(__FieldTag::__turns) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for turns",
));
}
result.turns = map.next_value::<std::option::Option<std::vec::Vec<crate::model::session::Turn>>>()?.unwrap_or_default();
}
__FieldTag::__labels => {
if !fields.insert(__FieldTag::__labels) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for labels",
));
}
result.labels = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__start_time => {
if !fields.insert(__FieldTag::__start_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for start_time",
));
}
result.start_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__end_time => {
if !fields.insert(__FieldTag::__end_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for end_time",
));
}
result.end_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__is_pinned => {
if !fields.insert(__FieldTag::__is_pinned) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for is_pinned",
));
}
result.is_pinned = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "conversational-search-service", feature = "session-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::session::Turn {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__query,
__answer,
__detailed_answer,
__detailed_assist_answer,
__query_config,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Turn")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"query" => Ok(__FieldTag::__query),
"answer" => Ok(__FieldTag::__answer),
"detailedAnswer" => Ok(__FieldTag::__detailed_answer),
"detailed_answer" => Ok(__FieldTag::__detailed_answer),
"detailedAssistAnswer" => Ok(__FieldTag::__detailed_assist_answer),
"detailed_assist_answer" => Ok(__FieldTag::__detailed_assist_answer),
"queryConfig" => Ok(__FieldTag::__query_config),
"query_config" => Ok(__FieldTag::__query_config),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::session::Turn;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Turn")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__query => {
if !fields.insert(__FieldTag::__query) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for query",
));
}
result.query =
map.next_value::<std::option::Option<crate::model::Query>>()?;
}
__FieldTag::__answer => {
if !fields.insert(__FieldTag::__answer) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for answer",
));
}
result.answer = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__detailed_answer => {
if !fields.insert(__FieldTag::__detailed_answer) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for detailed_answer",
));
}
result.detailed_answer =
map.next_value::<std::option::Option<crate::model::Answer>>()?;
}
__FieldTag::__detailed_assist_answer => {
if !fields.insert(__FieldTag::__detailed_assist_answer) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for detailed_assist_answer",
));
}
result.detailed_assist_answer = map
.next_value::<std::option::Option<crate::model::AssistAnswer>>()?;
}
__FieldTag::__query_config => {
if !fields.insert(__FieldTag::__query_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for query_config",
));
}
result.query_config = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
std::string::String,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(
feature = "assistant-service",
feature = "conversational-search-service",
feature = "session-service",
))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::Query {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__text,
__query_id,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Query")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"text" => Ok(__FieldTag::__text),
"queryId" => Ok(__FieldTag::__query_id),
"query_id" => Ok(__FieldTag::__query_id),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Query;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Query")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__text => {
if !fields.insert(__FieldTag::__text) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for text",
));
}
if result.content.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `content`, a oneof with full ID .google.cloud.discoveryengine.v1.Query.text, latest field was text",
));
}
result.content =
std::option::Option::Some(crate::model::query::Content::Text(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
));
}
__FieldTag::__query_id => {
if !fields.insert(__FieldTag::__query_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for query_id",
));
}
result.query_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::SiteSearchEngine {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SiteSearchEngine")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::SiteSearchEngine;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SiteSearchEngine")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::TargetSite {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
__provided_uri_pattern,
__type,
__exact_match,
__generated_uri_pattern,
__root_domain_uri,
__site_verification_info,
__indexing_status,
__update_time,
__failure_reason,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for TargetSite")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
"providedUriPattern" => Ok(__FieldTag::__provided_uri_pattern),
"provided_uri_pattern" => Ok(__FieldTag::__provided_uri_pattern),
"type" => Ok(__FieldTag::__type),
"exactMatch" => Ok(__FieldTag::__exact_match),
"exact_match" => Ok(__FieldTag::__exact_match),
"generatedUriPattern" => Ok(__FieldTag::__generated_uri_pattern),
"generated_uri_pattern" => Ok(__FieldTag::__generated_uri_pattern),
"rootDomainUri" => Ok(__FieldTag::__root_domain_uri),
"root_domain_uri" => Ok(__FieldTag::__root_domain_uri),
"siteVerificationInfo" => Ok(__FieldTag::__site_verification_info),
"site_verification_info" => Ok(__FieldTag::__site_verification_info),
"indexingStatus" => Ok(__FieldTag::__indexing_status),
"indexing_status" => Ok(__FieldTag::__indexing_status),
"updateTime" => Ok(__FieldTag::__update_time),
"update_time" => Ok(__FieldTag::__update_time),
"failureReason" => Ok(__FieldTag::__failure_reason),
"failure_reason" => Ok(__FieldTag::__failure_reason),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::TargetSite;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct TargetSite")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__provided_uri_pattern => {
if !fields.insert(__FieldTag::__provided_uri_pattern) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for provided_uri_pattern",
));
}
result.provided_uri_pattern = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__type => {
if !fields.insert(__FieldTag::__type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for type",
));
}
result.r#type = map
.next_value::<std::option::Option<crate::model::target_site::Type>>(
)?
.unwrap_or_default();
}
__FieldTag::__exact_match => {
if !fields.insert(__FieldTag::__exact_match) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for exact_match",
));
}
result.exact_match = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__generated_uri_pattern => {
if !fields.insert(__FieldTag::__generated_uri_pattern) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for generated_uri_pattern",
));
}
result.generated_uri_pattern = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__root_domain_uri => {
if !fields.insert(__FieldTag::__root_domain_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for root_domain_uri",
));
}
result.root_domain_uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__site_verification_info => {
if !fields.insert(__FieldTag::__site_verification_info) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for site_verification_info",
));
}
result.site_verification_info = map.next_value::<std::option::Option<crate::model::SiteVerificationInfo>>()?
;
}
__FieldTag::__indexing_status => {
if !fields.insert(__FieldTag::__indexing_status) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for indexing_status",
));
}
result.indexing_status = map.next_value::<std::option::Option<crate::model::target_site::IndexingStatus>>()?.unwrap_or_default();
}
__FieldTag::__update_time => {
if !fields.insert(__FieldTag::__update_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_time",
));
}
result.update_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__failure_reason => {
if !fields.insert(__FieldTag::__failure_reason) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for failure_reason",
));
}
result.failure_reason = map.next_value::<std::option::Option<crate::model::target_site::FailureReason>>()?
;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::target_site::FailureReason {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__quota_failure,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for FailureReason")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"quotaFailure" => Ok(__FieldTag::__quota_failure),
"quota_failure" => Ok(__FieldTag::__quota_failure),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::target_site::FailureReason;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct FailureReason")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__quota_failure => {
if !fields.insert(__FieldTag::__quota_failure) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for quota_failure",
));
}
if result.failure.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `failure`, a oneof with full ID .google.cloud.discoveryengine.v1.TargetSite.FailureReason.quota_failure, latest field was quotaFailure",
));
}
result.failure = std::option::Option::Some(
crate::model::target_site::failure_reason::Failure::QuotaFailure(
map.next_value::<std::option::Option<
std::boxed::Box<
crate::model::target_site::failure_reason::QuotaFailure,
>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::target_site::failure_reason::QuotaFailure {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__total_required_quota,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for QuotaFailure")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"totalRequiredQuota" => Ok(__FieldTag::__total_required_quota),
"total_required_quota" => Ok(__FieldTag::__total_required_quota),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::target_site::failure_reason::QuotaFailure;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct QuotaFailure")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__total_required_quota => {
if !fields.insert(__FieldTag::__total_required_quota) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for total_required_quota",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.total_required_quota =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::SiteVerificationInfo {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__site_verification_state,
__verify_time,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SiteVerificationInfo")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"siteVerificationState" => Ok(__FieldTag::__site_verification_state),
"site_verification_state" => Ok(__FieldTag::__site_verification_state),
"verifyTime" => Ok(__FieldTag::__verify_time),
"verify_time" => Ok(__FieldTag::__verify_time),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::SiteVerificationInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SiteVerificationInfo")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__site_verification_state => {
if !fields.insert(__FieldTag::__site_verification_state) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for site_verification_state",
));
}
result.site_verification_state = map
.next_value::<std::option::Option<
crate::model::site_verification_info::SiteVerificationState,
>>()?
.unwrap_or_default();
}
__FieldTag::__verify_time => {
if !fields.insert(__FieldTag::__verify_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for verify_time",
));
}
result.verify_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::Sitemap {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__uri,
__name,
__create_time,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Sitemap")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"uri" => Ok(__FieldTag::__uri),
"name" => Ok(__FieldTag::__name),
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::Sitemap;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Sitemap")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__uri => {
if !fields.insert(__FieldTag::__uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for uri",
));
}
if result.feed.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `feed`, a oneof with full ID .google.cloud.discoveryengine.v1.Sitemap.uri, latest field was uri",
));
}
result.feed =
std::option::Option::Some(crate::model::sitemap::Feed::Uri(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
));
}
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::GetSiteSearchEngineRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for GetSiteSearchEngineRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::GetSiteSearchEngineRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GetSiteSearchEngineRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::CreateTargetSiteRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__parent,
__target_site,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for CreateTargetSiteRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"parent" => Ok(__FieldTag::__parent),
"targetSite" => Ok(__FieldTag::__target_site),
"target_site" => Ok(__FieldTag::__target_site),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CreateTargetSiteRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CreateTargetSiteRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__target_site => {
if !fields.insert(__FieldTag::__target_site) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for target_site",
));
}
result.target_site =
map.next_value::<std::option::Option<crate::model::TargetSite>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::CreateTargetSiteMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__create_time,
__update_time,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for CreateTargetSiteMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"updateTime" => Ok(__FieldTag::__update_time),
"update_time" => Ok(__FieldTag::__update_time),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CreateTargetSiteMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CreateTargetSiteMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__update_time => {
if !fields.insert(__FieldTag::__update_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_time",
));
}
result.update_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::BatchCreateTargetSitesRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__parent,
__requests,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for BatchCreateTargetSitesRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"parent" => Ok(__FieldTag::__parent),
"requests" => Ok(__FieldTag::__requests),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::BatchCreateTargetSitesRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BatchCreateTargetSitesRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__requests => {
if !fields.insert(__FieldTag::__requests) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for requests",
));
}
result.requests = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::CreateTargetSiteRequest>,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::GetTargetSiteRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for GetTargetSiteRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::GetTargetSiteRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct GetTargetSiteRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::UpdateTargetSiteRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__target_site,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for UpdateTargetSiteRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"targetSite" => Ok(__FieldTag::__target_site),
"target_site" => Ok(__FieldTag::__target_site),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::UpdateTargetSiteRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct UpdateTargetSiteRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__target_site => {
if !fields.insert(__FieldTag::__target_site) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for target_site",
));
}
result.target_site =
map.next_value::<std::option::Option<crate::model::TargetSite>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::UpdateTargetSiteMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__create_time,
__update_time,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for UpdateTargetSiteMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"updateTime" => Ok(__FieldTag::__update_time),
"update_time" => Ok(__FieldTag::__update_time),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::UpdateTargetSiteMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct UpdateTargetSiteMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__update_time => {
if !fields.insert(__FieldTag::__update_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_time",
));
}
result.update_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::DeleteTargetSiteRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DeleteTargetSiteRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DeleteTargetSiteRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DeleteTargetSiteRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::DeleteTargetSiteMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__create_time,
__update_time,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DeleteTargetSiteMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"updateTime" => Ok(__FieldTag::__update_time),
"update_time" => Ok(__FieldTag::__update_time),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DeleteTargetSiteMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DeleteTargetSiteMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__update_time => {
if !fields.insert(__FieldTag::__update_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_time",
));
}
result.update_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ListTargetSitesRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__parent,
__page_size,
__page_token,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ListTargetSitesRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"parent" => Ok(__FieldTag::__parent),
"pageSize" => Ok(__FieldTag::__page_size),
"page_size" => Ok(__FieldTag::__page_size),
"pageToken" => Ok(__FieldTag::__page_token),
"page_token" => Ok(__FieldTag::__page_token),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListTargetSitesRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListTargetSitesRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__page_size => {
if !fields.insert(__FieldTag::__page_size) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_size",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.page_size = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__page_token => {
if !fields.insert(__FieldTag::__page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_token",
));
}
result.page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ListTargetSitesResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__target_sites,
__next_page_token,
__total_size,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ListTargetSitesResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"targetSites" => Ok(__FieldTag::__target_sites),
"target_sites" => Ok(__FieldTag::__target_sites),
"nextPageToken" => Ok(__FieldTag::__next_page_token),
"next_page_token" => Ok(__FieldTag::__next_page_token),
"totalSize" => Ok(__FieldTag::__total_size),
"total_size" => Ok(__FieldTag::__total_size),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListTargetSitesResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListTargetSitesResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__target_sites => {
if !fields.insert(__FieldTag::__target_sites) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for target_sites",
));
}
result.target_sites = map.next_value::<std::option::Option<std::vec::Vec<crate::model::TargetSite>>>()?.unwrap_or_default();
}
__FieldTag::__next_page_token => {
if !fields.insert(__FieldTag::__next_page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for next_page_token",
));
}
result.next_page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__total_size => {
if !fields.insert(__FieldTag::__total_size) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for total_size",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.total_size = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::BatchCreateTargetSiteMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__create_time,
__update_time,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for BatchCreateTargetSiteMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"updateTime" => Ok(__FieldTag::__update_time),
"update_time" => Ok(__FieldTag::__update_time),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::BatchCreateTargetSiteMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BatchCreateTargetSiteMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__update_time => {
if !fields.insert(__FieldTag::__update_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_time",
));
}
result.update_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::BatchCreateTargetSitesResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__target_sites,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for BatchCreateTargetSitesResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"targetSites" => Ok(__FieldTag::__target_sites),
"target_sites" => Ok(__FieldTag::__target_sites),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::BatchCreateTargetSitesResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BatchCreateTargetSitesResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__target_sites => {
if !fields.insert(__FieldTag::__target_sites) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for target_sites",
));
}
result.target_sites = map.next_value::<std::option::Option<std::vec::Vec<crate::model::TargetSite>>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::CreateSitemapRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__parent,
__sitemap,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for CreateSitemapRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"parent" => Ok(__FieldTag::__parent),
"sitemap" => Ok(__FieldTag::__sitemap),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CreateSitemapRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CreateSitemapRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__sitemap => {
if !fields.insert(__FieldTag::__sitemap) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for sitemap",
));
}
result.sitemap =
map.next_value::<std::option::Option<crate::model::Sitemap>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::DeleteSitemapRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__name,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DeleteSitemapRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"name" => Ok(__FieldTag::__name),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DeleteSitemapRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DeleteSitemapRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
result.name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::FetchSitemapsRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__parent,
__matcher,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for FetchSitemapsRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"parent" => Ok(__FieldTag::__parent),
"matcher" => Ok(__FieldTag::__matcher),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::FetchSitemapsRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct FetchSitemapsRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__matcher => {
if !fields.insert(__FieldTag::__matcher) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for matcher",
));
}
result.matcher = map.next_value::<std::option::Option<
crate::model::fetch_sitemaps_request::Matcher,
>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::fetch_sitemaps_request::UrisMatcher {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__uris,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for UrisMatcher")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"uris" => Ok(__FieldTag::__uris),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::fetch_sitemaps_request::UrisMatcher;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct UrisMatcher")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__uris => {
if !fields.insert(__FieldTag::__uris) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for uris",
));
}
result.uris = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::fetch_sitemaps_request::Matcher {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__uris_matcher,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for Matcher")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"urisMatcher" => Ok(__FieldTag::__uris_matcher),
"uris_matcher" => Ok(__FieldTag::__uris_matcher),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::fetch_sitemaps_request::Matcher;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct Matcher")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__uris_matcher => {
if !fields.insert(__FieldTag::__uris_matcher) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for uris_matcher",
));
}
if result.matcher.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `matcher`, a oneof with full ID .google.cloud.discoveryengine.v1.FetchSitemapsRequest.Matcher.uris_matcher, latest field was urisMatcher",
));
}
result.matcher = std::option::Option::Some(
crate::model::fetch_sitemaps_request::matcher::Matcher::UrisMatcher(
map.next_value::<std::option::Option<
std::boxed::Box<
crate::model::fetch_sitemaps_request::UrisMatcher,
>,
>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::CreateSitemapMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__create_time,
__update_time,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for CreateSitemapMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"updateTime" => Ok(__FieldTag::__update_time),
"update_time" => Ok(__FieldTag::__update_time),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CreateSitemapMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CreateSitemapMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__update_time => {
if !fields.insert(__FieldTag::__update_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_time",
));
}
result.update_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::DeleteSitemapMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__create_time,
__update_time,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DeleteSitemapMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"updateTime" => Ok(__FieldTag::__update_time),
"update_time" => Ok(__FieldTag::__update_time),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DeleteSitemapMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DeleteSitemapMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__update_time => {
if !fields.insert(__FieldTag::__update_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_time",
));
}
result.update_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::FetchSitemapsResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__sitemaps_metadata,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for FetchSitemapsResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"sitemapsMetadata" => Ok(__FieldTag::__sitemaps_metadata),
"sitemaps_metadata" => Ok(__FieldTag::__sitemaps_metadata),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::FetchSitemapsResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct FetchSitemapsResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__sitemaps_metadata => {
if !fields.insert(__FieldTag::__sitemaps_metadata) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for sitemaps_metadata",
));
}
result.sitemaps_metadata = map
.next_value::<std::option::Option<
std::vec::Vec<
crate::model::fetch_sitemaps_response::SitemapMetadata,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::fetch_sitemaps_response::SitemapMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__sitemap,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SitemapMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"sitemap" => Ok(__FieldTag::__sitemap),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::fetch_sitemaps_response::SitemapMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SitemapMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__sitemap => {
if !fields.insert(__FieldTag::__sitemap) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for sitemap",
));
}
result.sitemap =
map.next_value::<std::option::Option<crate::model::Sitemap>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::EnableAdvancedSiteSearchRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__site_search_engine,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for EnableAdvancedSiteSearchRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"siteSearchEngine" => Ok(__FieldTag::__site_search_engine),
"site_search_engine" => Ok(__FieldTag::__site_search_engine),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::EnableAdvancedSiteSearchRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct EnableAdvancedSiteSearchRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__site_search_engine => {
if !fields.insert(__FieldTag::__site_search_engine) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for site_search_engine",
));
}
result.site_search_engine = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::EnableAdvancedSiteSearchResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for EnableAdvancedSiteSearchResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
Ok(__FieldTag::Unknown(value.to_string()))
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::EnableAdvancedSiteSearchResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct EnableAdvancedSiteSearchResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::EnableAdvancedSiteSearchMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__create_time,
__update_time,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for EnableAdvancedSiteSearchMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"updateTime" => Ok(__FieldTag::__update_time),
"update_time" => Ok(__FieldTag::__update_time),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::EnableAdvancedSiteSearchMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct EnableAdvancedSiteSearchMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__update_time => {
if !fields.insert(__FieldTag::__update_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_time",
));
}
result.update_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::DisableAdvancedSiteSearchRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__site_search_engine,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DisableAdvancedSiteSearchRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"siteSearchEngine" => Ok(__FieldTag::__site_search_engine),
"site_search_engine" => Ok(__FieldTag::__site_search_engine),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DisableAdvancedSiteSearchRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DisableAdvancedSiteSearchRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__site_search_engine => {
if !fields.insert(__FieldTag::__site_search_engine) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for site_search_engine",
));
}
result.site_search_engine = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::DisableAdvancedSiteSearchResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DisableAdvancedSiteSearchResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
Ok(__FieldTag::Unknown(value.to_string()))
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DisableAdvancedSiteSearchResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DisableAdvancedSiteSearchResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::DisableAdvancedSiteSearchMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__create_time,
__update_time,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DisableAdvancedSiteSearchMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"updateTime" => Ok(__FieldTag::__update_time),
"update_time" => Ok(__FieldTag::__update_time),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DisableAdvancedSiteSearchMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DisableAdvancedSiteSearchMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__update_time => {
if !fields.insert(__FieldTag::__update_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_time",
));
}
result.update_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::RecrawlUrisRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__site_search_engine,
__uris,
__site_credential,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for RecrawlUrisRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"siteSearchEngine" => Ok(__FieldTag::__site_search_engine),
"site_search_engine" => Ok(__FieldTag::__site_search_engine),
"uris" => Ok(__FieldTag::__uris),
"siteCredential" => Ok(__FieldTag::__site_credential),
"site_credential" => Ok(__FieldTag::__site_credential),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::RecrawlUrisRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct RecrawlUrisRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__site_search_engine => {
if !fields.insert(__FieldTag::__site_search_engine) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for site_search_engine",
));
}
result.site_search_engine = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__uris => {
if !fields.insert(__FieldTag::__uris) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for uris",
));
}
result.uris = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__site_credential => {
if !fields.insert(__FieldTag::__site_credential) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for site_credential",
));
}
result.site_credential = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::RecrawlUrisResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__failure_samples,
__failed_uris,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for RecrawlUrisResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"failureSamples" => Ok(__FieldTag::__failure_samples),
"failure_samples" => Ok(__FieldTag::__failure_samples),
"failedUris" => Ok(__FieldTag::__failed_uris),
"failed_uris" => Ok(__FieldTag::__failed_uris),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::RecrawlUrisResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct RecrawlUrisResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__failure_samples => {
if !fields.insert(__FieldTag::__failure_samples) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for failure_samples",
));
}
result.failure_samples = map
.next_value::<std::option::Option<
std::vec::Vec<crate::model::recrawl_uris_response::FailureInfo>,
>>()?
.unwrap_or_default();
}
__FieldTag::__failed_uris => {
if !fields.insert(__FieldTag::__failed_uris) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for failed_uris",
));
}
result.failed_uris = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::recrawl_uris_response::FailureInfo {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__uri,
__failure_reasons,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for FailureInfo")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"uri" => Ok(__FieldTag::__uri),
"failureReasons" => Ok(__FieldTag::__failure_reasons),
"failure_reasons" => Ok(__FieldTag::__failure_reasons),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::recrawl_uris_response::FailureInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct FailureInfo")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__uri => {
if !fields.insert(__FieldTag::__uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for uri",
));
}
result.uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__failure_reasons => {
if !fields.insert(__FieldTag::__failure_reasons) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for failure_reasons",
));
}
result.failure_reasons = map.next_value::<std::option::Option<std::vec::Vec<crate::model::recrawl_uris_response::failure_info::FailureReason>>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de>
for super::recrawl_uris_response::failure_info::FailureReason
{
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__corpus_type,
__error_message,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for FailureReason")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"corpusType" => Ok(__FieldTag::__corpus_type),
"corpus_type" => Ok(__FieldTag::__corpus_type),
"errorMessage" => Ok(__FieldTag::__error_message),
"error_message" => Ok(__FieldTag::__error_message),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::recrawl_uris_response::failure_info::FailureReason;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct FailureReason")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__corpus_type => {
if !fields.insert(__FieldTag::__corpus_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for corpus_type",
));
}
result.corpus_type = map.next_value::<std::option::Option<crate::model::recrawl_uris_response::failure_info::failure_reason::CorpusType>>()?.unwrap_or_default();
}
__FieldTag::__error_message => {
if !fields.insert(__FieldTag::__error_message) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for error_message",
));
}
result.error_message = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::RecrawlUrisMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__create_time,
__update_time,
__invalid_uris,
__invalid_uris_count,
__noindex_uris,
__noindex_uris_count,
__uris_not_matching_target_sites,
__uris_not_matching_target_sites_count,
__valid_uris_count,
__success_count,
__pending_count,
__quota_exceeded_count,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for RecrawlUrisMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"updateTime" => Ok(__FieldTag::__update_time),
"update_time" => Ok(__FieldTag::__update_time),
"invalidUris" => Ok(__FieldTag::__invalid_uris),
"invalid_uris" => Ok(__FieldTag::__invalid_uris),
"invalidUrisCount" => Ok(__FieldTag::__invalid_uris_count),
"invalid_uris_count" => Ok(__FieldTag::__invalid_uris_count),
"noindexUris" => Ok(__FieldTag::__noindex_uris),
"noindex_uris" => Ok(__FieldTag::__noindex_uris),
"noindexUrisCount" => Ok(__FieldTag::__noindex_uris_count),
"noindex_uris_count" => Ok(__FieldTag::__noindex_uris_count),
"urisNotMatchingTargetSites" => {
Ok(__FieldTag::__uris_not_matching_target_sites)
}
"uris_not_matching_target_sites" => {
Ok(__FieldTag::__uris_not_matching_target_sites)
}
"urisNotMatchingTargetSitesCount" => {
Ok(__FieldTag::__uris_not_matching_target_sites_count)
}
"uris_not_matching_target_sites_count" => {
Ok(__FieldTag::__uris_not_matching_target_sites_count)
}
"validUrisCount" => Ok(__FieldTag::__valid_uris_count),
"valid_uris_count" => Ok(__FieldTag::__valid_uris_count),
"successCount" => Ok(__FieldTag::__success_count),
"success_count" => Ok(__FieldTag::__success_count),
"pendingCount" => Ok(__FieldTag::__pending_count),
"pending_count" => Ok(__FieldTag::__pending_count),
"quotaExceededCount" => Ok(__FieldTag::__quota_exceeded_count),
"quota_exceeded_count" => Ok(__FieldTag::__quota_exceeded_count),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::RecrawlUrisMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct RecrawlUrisMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__update_time => {
if !fields.insert(__FieldTag::__update_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_time",
));
}
result.update_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__invalid_uris => {
if !fields.insert(__FieldTag::__invalid_uris) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for invalid_uris",
));
}
result.invalid_uris = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__invalid_uris_count => {
if !fields.insert(__FieldTag::__invalid_uris_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for invalid_uris_count",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.invalid_uris_count =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__noindex_uris => {
if !fields.insert(__FieldTag::__noindex_uris) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for noindex_uris",
));
}
result.noindex_uris = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__noindex_uris_count => {
if !fields.insert(__FieldTag::__noindex_uris_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for noindex_uris_count",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.noindex_uris_count =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__uris_not_matching_target_sites => {
if !fields.insert(__FieldTag::__uris_not_matching_target_sites) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for uris_not_matching_target_sites",
));
}
result.uris_not_matching_target_sites = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__uris_not_matching_target_sites_count => {
if !fields.insert(__FieldTag::__uris_not_matching_target_sites_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for uris_not_matching_target_sites_count",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.uris_not_matching_target_sites_count =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__valid_uris_count => {
if !fields.insert(__FieldTag::__valid_uris_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for valid_uris_count",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.valid_uris_count =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__success_count => {
if !fields.insert(__FieldTag::__success_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for success_count",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.success_count =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__pending_count => {
if !fields.insert(__FieldTag::__pending_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for pending_count",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.pending_count =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__quota_exceeded_count => {
if !fields.insert(__FieldTag::__quota_exceeded_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for quota_exceeded_count",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.quota_exceeded_count =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::BatchVerifyTargetSitesRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__parent,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for BatchVerifyTargetSitesRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"parent" => Ok(__FieldTag::__parent),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::BatchVerifyTargetSitesRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BatchVerifyTargetSitesRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::BatchVerifyTargetSitesResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for BatchVerifyTargetSitesResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
Ok(__FieldTag::Unknown(value.to_string()))
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::BatchVerifyTargetSitesResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BatchVerifyTargetSitesResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::BatchVerifyTargetSitesMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__create_time,
__update_time,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for BatchVerifyTargetSitesMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"updateTime" => Ok(__FieldTag::__update_time),
"update_time" => Ok(__FieldTag::__update_time),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::BatchVerifyTargetSitesMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BatchVerifyTargetSitesMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__update_time => {
if !fields.insert(__FieldTag::__update_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_time",
));
}
result.update_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::FetchDomainVerificationStatusRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__site_search_engine,
__page_size,
__page_token,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for FetchDomainVerificationStatusRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"siteSearchEngine" => Ok(__FieldTag::__site_search_engine),
"site_search_engine" => Ok(__FieldTag::__site_search_engine),
"pageSize" => Ok(__FieldTag::__page_size),
"page_size" => Ok(__FieldTag::__page_size),
"pageToken" => Ok(__FieldTag::__page_token),
"page_token" => Ok(__FieldTag::__page_token),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::FetchDomainVerificationStatusRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct FetchDomainVerificationStatusRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__site_search_engine => {
if !fields.insert(__FieldTag::__site_search_engine) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for site_search_engine",
));
}
result.site_search_engine = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__page_size => {
if !fields.insert(__FieldTag::__page_size) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_size",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.page_size = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__page_token => {
if !fields.insert(__FieldTag::__page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_token",
));
}
result.page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "site-search-engine-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::FetchDomainVerificationStatusResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__target_sites,
__next_page_token,
__total_size,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter
.write_str("a field name for FetchDomainVerificationStatusResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"targetSites" => Ok(__FieldTag::__target_sites),
"target_sites" => Ok(__FieldTag::__target_sites),
"nextPageToken" => Ok(__FieldTag::__next_page_token),
"next_page_token" => Ok(__FieldTag::__next_page_token),
"totalSize" => Ok(__FieldTag::__total_size),
"total_size" => Ok(__FieldTag::__total_size),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::FetchDomainVerificationStatusResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct FetchDomainVerificationStatusResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__target_sites => {
if !fields.insert(__FieldTag::__target_sites) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for target_sites",
));
}
result.target_sites = map.next_value::<std::option::Option<std::vec::Vec<crate::model::TargetSite>>>()?.unwrap_or_default();
}
__FieldTag::__next_page_token => {
if !fields.insert(__FieldTag::__next_page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for next_page_token",
));
}
result.next_page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__total_size => {
if !fields.insert(__FieldTag::__total_size) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for total_size",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.total_size = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "recommendation-service", feature = "user-event-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::UserEvent {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__event_type,
__conversion_type,
__user_pseudo_id,
__engine,
__data_store,
__event_time,
__user_info,
__direct_user_request,
__session_id,
__page_info,
__attribution_token,
__filter,
__documents,
__panel,
__search_info,
__completion_info,
__transaction_info,
__tag_ids,
__promotion_ids,
__attributes,
__media_info,
__panels,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for UserEvent")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"eventType" => Ok(__FieldTag::__event_type),
"event_type" => Ok(__FieldTag::__event_type),
"conversionType" => Ok(__FieldTag::__conversion_type),
"conversion_type" => Ok(__FieldTag::__conversion_type),
"userPseudoId" => Ok(__FieldTag::__user_pseudo_id),
"user_pseudo_id" => Ok(__FieldTag::__user_pseudo_id),
"engine" => Ok(__FieldTag::__engine),
"dataStore" => Ok(__FieldTag::__data_store),
"data_store" => Ok(__FieldTag::__data_store),
"eventTime" => Ok(__FieldTag::__event_time),
"event_time" => Ok(__FieldTag::__event_time),
"userInfo" => Ok(__FieldTag::__user_info),
"user_info" => Ok(__FieldTag::__user_info),
"directUserRequest" => Ok(__FieldTag::__direct_user_request),
"direct_user_request" => Ok(__FieldTag::__direct_user_request),
"sessionId" => Ok(__FieldTag::__session_id),
"session_id" => Ok(__FieldTag::__session_id),
"pageInfo" => Ok(__FieldTag::__page_info),
"page_info" => Ok(__FieldTag::__page_info),
"attributionToken" => Ok(__FieldTag::__attribution_token),
"attribution_token" => Ok(__FieldTag::__attribution_token),
"filter" => Ok(__FieldTag::__filter),
"documents" => Ok(__FieldTag::__documents),
"panel" => Ok(__FieldTag::__panel),
"searchInfo" => Ok(__FieldTag::__search_info),
"search_info" => Ok(__FieldTag::__search_info),
"completionInfo" => Ok(__FieldTag::__completion_info),
"completion_info" => Ok(__FieldTag::__completion_info),
"transactionInfo" => Ok(__FieldTag::__transaction_info),
"transaction_info" => Ok(__FieldTag::__transaction_info),
"tagIds" => Ok(__FieldTag::__tag_ids),
"tag_ids" => Ok(__FieldTag::__tag_ids),
"promotionIds" => Ok(__FieldTag::__promotion_ids),
"promotion_ids" => Ok(__FieldTag::__promotion_ids),
"attributes" => Ok(__FieldTag::__attributes),
"mediaInfo" => Ok(__FieldTag::__media_info),
"media_info" => Ok(__FieldTag::__media_info),
"panels" => Ok(__FieldTag::__panels),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::UserEvent;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct UserEvent")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__event_type => {
if !fields.insert(__FieldTag::__event_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for event_type",
));
}
result.event_type = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__conversion_type => {
if !fields.insert(__FieldTag::__conversion_type) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for conversion_type",
));
}
result.conversion_type = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__user_pseudo_id => {
if !fields.insert(__FieldTag::__user_pseudo_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for user_pseudo_id",
));
}
result.user_pseudo_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__engine => {
if !fields.insert(__FieldTag::__engine) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for engine",
));
}
result.engine = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__data_store => {
if !fields.insert(__FieldTag::__data_store) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for data_store",
));
}
result.data_store = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__event_time => {
if !fields.insert(__FieldTag::__event_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for event_time",
));
}
result.event_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__user_info => {
if !fields.insert(__FieldTag::__user_info) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for user_info",
));
}
result.user_info =
map.next_value::<std::option::Option<crate::model::UserInfo>>()?;
}
__FieldTag::__direct_user_request => {
if !fields.insert(__FieldTag::__direct_user_request) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for direct_user_request",
));
}
result.direct_user_request = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__session_id => {
if !fields.insert(__FieldTag::__session_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for session_id",
));
}
result.session_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__page_info => {
if !fields.insert(__FieldTag::__page_info) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_info",
));
}
result.page_info =
map.next_value::<std::option::Option<crate::model::PageInfo>>()?;
}
__FieldTag::__attribution_token => {
if !fields.insert(__FieldTag::__attribution_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for attribution_token",
));
}
result.attribution_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__filter => {
if !fields.insert(__FieldTag::__filter) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for filter",
));
}
result.filter = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__documents => {
if !fields.insert(__FieldTag::__documents) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for documents",
));
}
result.documents = map.next_value::<std::option::Option<std::vec::Vec<crate::model::DocumentInfo>>>()?.unwrap_or_default();
}
__FieldTag::__panel => {
if !fields.insert(__FieldTag::__panel) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for panel",
));
}
result.panel =
map.next_value::<std::option::Option<crate::model::PanelInfo>>()?;
}
__FieldTag::__search_info => {
if !fields.insert(__FieldTag::__search_info) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for search_info",
));
}
result.search_info =
map.next_value::<std::option::Option<crate::model::SearchInfo>>()?;
}
__FieldTag::__completion_info => {
if !fields.insert(__FieldTag::__completion_info) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for completion_info",
));
}
result.completion_info = map
.next_value::<std::option::Option<crate::model::CompletionInfo>>(
)?;
}
__FieldTag::__transaction_info => {
if !fields.insert(__FieldTag::__transaction_info) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for transaction_info",
));
}
result.transaction_info = map
.next_value::<std::option::Option<crate::model::TransactionInfo>>(
)?;
}
__FieldTag::__tag_ids => {
if !fields.insert(__FieldTag::__tag_ids) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for tag_ids",
));
}
result.tag_ids = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__promotion_ids => {
if !fields.insert(__FieldTag::__promotion_ids) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for promotion_ids",
));
}
result.promotion_ids = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__attributes => {
if !fields.insert(__FieldTag::__attributes) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for attributes",
));
}
result.attributes = map
.next_value::<std::option::Option<
std::collections::HashMap<
std::string::String,
crate::model::CustomAttribute,
>,
>>()?
.unwrap_or_default();
}
__FieldTag::__media_info => {
if !fields.insert(__FieldTag::__media_info) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for media_info",
));
}
result.media_info =
map.next_value::<std::option::Option<crate::model::MediaInfo>>()?;
}
__FieldTag::__panels => {
if !fields.insert(__FieldTag::__panels) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for panels",
));
}
result.panels = map.next_value::<std::option::Option<std::vec::Vec<crate::model::PanelInfo>>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "recommendation-service", feature = "user-event-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::PageInfo {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__pageview_id,
__page_category,
__uri,
__referrer_uri,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for PageInfo")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"pageviewId" => Ok(__FieldTag::__pageview_id),
"pageview_id" => Ok(__FieldTag::__pageview_id),
"pageCategory" => Ok(__FieldTag::__page_category),
"page_category" => Ok(__FieldTag::__page_category),
"uri" => Ok(__FieldTag::__uri),
"referrerUri" => Ok(__FieldTag::__referrer_uri),
"referrer_uri" => Ok(__FieldTag::__referrer_uri),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::PageInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct PageInfo")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__pageview_id => {
if !fields.insert(__FieldTag::__pageview_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for pageview_id",
));
}
result.pageview_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__page_category => {
if !fields.insert(__FieldTag::__page_category) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_category",
));
}
result.page_category = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__uri => {
if !fields.insert(__FieldTag::__uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for uri",
));
}
result.uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__referrer_uri => {
if !fields.insert(__FieldTag::__referrer_uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for referrer_uri",
));
}
result.referrer_uri = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "recommendation-service", feature = "user-event-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::SearchInfo {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__search_query,
__order_by,
__offset,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for SearchInfo")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"searchQuery" => Ok(__FieldTag::__search_query),
"search_query" => Ok(__FieldTag::__search_query),
"orderBy" => Ok(__FieldTag::__order_by),
"order_by" => Ok(__FieldTag::__order_by),
"offset" => Ok(__FieldTag::__offset),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::SearchInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct SearchInfo")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__search_query => {
if !fields.insert(__FieldTag::__search_query) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for search_query",
));
}
result.search_query = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__order_by => {
if !fields.insert(__FieldTag::__order_by) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for order_by",
));
}
result.order_by = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__offset => {
if !fields.insert(__FieldTag::__offset) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for offset",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.offset = map.next_value::<__With>()?.0;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "recommendation-service", feature = "user-event-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::CompletionInfo {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__selected_suggestion,
__selected_position,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for CompletionInfo")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"selectedSuggestion" => Ok(__FieldTag::__selected_suggestion),
"selected_suggestion" => Ok(__FieldTag::__selected_suggestion),
"selectedPosition" => Ok(__FieldTag::__selected_position),
"selected_position" => Ok(__FieldTag::__selected_position),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CompletionInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CompletionInfo")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__selected_suggestion => {
if !fields.insert(__FieldTag::__selected_suggestion) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for selected_suggestion",
));
}
result.selected_suggestion = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__selected_position => {
if !fields.insert(__FieldTag::__selected_position) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for selected_position",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.selected_position =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "recommendation-service", feature = "user-event-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::TransactionInfo {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__value,
__currency,
__transaction_id,
__tax,
__cost,
__discount_value,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for TransactionInfo")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"value" => Ok(__FieldTag::__value),
"currency" => Ok(__FieldTag::__currency),
"transactionId" => Ok(__FieldTag::__transaction_id),
"transaction_id" => Ok(__FieldTag::__transaction_id),
"tax" => Ok(__FieldTag::__tax),
"cost" => Ok(__FieldTag::__cost),
"discountValue" => Ok(__FieldTag::__discount_value),
"discount_value" => Ok(__FieldTag::__discount_value),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::TransactionInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct TransactionInfo")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__value => {
if !fields.insert(__FieldTag::__value) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for value",
));
}
struct __With(std::option::Option<f32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F32> >::deserialize(deserializer).map(__With)
}
}
result.value = map.next_value::<__With>()?.0;
}
__FieldTag::__currency => {
if !fields.insert(__FieldTag::__currency) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for currency",
));
}
result.currency = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__transaction_id => {
if !fields.insert(__FieldTag::__transaction_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for transaction_id",
));
}
result.transaction_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__tax => {
if !fields.insert(__FieldTag::__tax) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for tax",
));
}
struct __With(std::option::Option<f32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F32> >::deserialize(deserializer).map(__With)
}
}
result.tax = map.next_value::<__With>()?.0;
}
__FieldTag::__cost => {
if !fields.insert(__FieldTag::__cost) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for cost",
));
}
struct __With(std::option::Option<f32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F32> >::deserialize(deserializer).map(__With)
}
}
result.cost = map.next_value::<__With>()?.0;
}
__FieldTag::__discount_value => {
if !fields.insert(__FieldTag::__discount_value) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for discount_value",
));
}
struct __With(std::option::Option<f32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F32> >::deserialize(deserializer).map(__With)
}
}
result.discount_value = map.next_value::<__With>()?.0;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "recommendation-service", feature = "user-event-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::DocumentInfo {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__id,
__name,
__uri,
__quantity,
__promotion_ids,
__joined,
__conversion_value,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for DocumentInfo")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"id" => Ok(__FieldTag::__id),
"name" => Ok(__FieldTag::__name),
"uri" => Ok(__FieldTag::__uri),
"quantity" => Ok(__FieldTag::__quantity),
"promotionIds" => Ok(__FieldTag::__promotion_ids),
"promotion_ids" => Ok(__FieldTag::__promotion_ids),
"joined" => Ok(__FieldTag::__joined),
"conversionValue" => Ok(__FieldTag::__conversion_value),
"conversion_value" => Ok(__FieldTag::__conversion_value),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::DocumentInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct DocumentInfo")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__id => {
if !fields.insert(__FieldTag::__id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for id",
));
}
if result.document_descriptor.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `document_descriptor`, a oneof with full ID .google.cloud.discoveryengine.v1.DocumentInfo.id, latest field was id",
));
}
result.document_descriptor = std::option::Option::Some(
crate::model::document_info::DocumentDescriptor::Id(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__name => {
if !fields.insert(__FieldTag::__name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for name",
));
}
if result.document_descriptor.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `document_descriptor`, a oneof with full ID .google.cloud.discoveryengine.v1.DocumentInfo.name, latest field was name",
));
}
result.document_descriptor = std::option::Option::Some(
crate::model::document_info::DocumentDescriptor::Name(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__uri => {
if !fields.insert(__FieldTag::__uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for uri",
));
}
if result.document_descriptor.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `document_descriptor`, a oneof with full ID .google.cloud.discoveryengine.v1.DocumentInfo.uri, latest field was uri",
));
}
result.document_descriptor = std::option::Option::Some(
crate::model::document_info::DocumentDescriptor::Uri(
map.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default(),
),
);
}
__FieldTag::__quantity => {
if !fields.insert(__FieldTag::__quantity) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for quantity",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.quantity = map.next_value::<__With>()?.0;
}
__FieldTag::__promotion_ids => {
if !fields.insert(__FieldTag::__promotion_ids) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for promotion_ids",
));
}
result.promotion_ids = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
}
__FieldTag::__joined => {
if !fields.insert(__FieldTag::__joined) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for joined",
));
}
result.joined = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::__conversion_value => {
if !fields.insert(__FieldTag::__conversion_value) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for conversion_value",
));
}
struct __With(std::option::Option<f32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F32> >::deserialize(deserializer).map(__With)
}
}
result.conversion_value = map.next_value::<__With>()?.0;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "recommendation-service", feature = "user-event-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::PanelInfo {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__panel_id,
__display_name,
__panel_position,
__total_panels,
__documents,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for PanelInfo")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"panelId" => Ok(__FieldTag::__panel_id),
"panel_id" => Ok(__FieldTag::__panel_id),
"displayName" => Ok(__FieldTag::__display_name),
"display_name" => Ok(__FieldTag::__display_name),
"panelPosition" => Ok(__FieldTag::__panel_position),
"panel_position" => Ok(__FieldTag::__panel_position),
"totalPanels" => Ok(__FieldTag::__total_panels),
"total_panels" => Ok(__FieldTag::__total_panels),
"documents" => Ok(__FieldTag::__documents),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::PanelInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct PanelInfo")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__panel_id => {
if !fields.insert(__FieldTag::__panel_id) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for panel_id",
));
}
result.panel_id = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__display_name => {
if !fields.insert(__FieldTag::__display_name) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for display_name",
));
}
result.display_name = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__panel_position => {
if !fields.insert(__FieldTag::__panel_position) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for panel_position",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.panel_position = map.next_value::<__With>()?.0;
}
__FieldTag::__total_panels => {
if !fields.insert(__FieldTag::__total_panels) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for total_panels",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.total_panels = map.next_value::<__With>()?.0;
}
__FieldTag::__documents => {
if !fields.insert(__FieldTag::__documents) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for documents",
));
}
result.documents = map.next_value::<std::option::Option<std::vec::Vec<crate::model::DocumentInfo>>>()?.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(any(feature = "recommendation-service", feature = "user-event-service",))]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::MediaInfo {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__media_progress_duration,
__media_progress_percentage,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for MediaInfo")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"mediaProgressDuration" => Ok(__FieldTag::__media_progress_duration),
"media_progress_duration" => Ok(__FieldTag::__media_progress_duration),
"mediaProgressPercentage" => {
Ok(__FieldTag::__media_progress_percentage)
}
"media_progress_percentage" => {
Ok(__FieldTag::__media_progress_percentage)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::MediaInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct MediaInfo")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__media_progress_duration => {
if !fields.insert(__FieldTag::__media_progress_duration) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for media_progress_duration",
));
}
result.media_progress_duration =
map.next_value::<std::option::Option<wkt::Duration>>()?;
}
__FieldTag::__media_progress_percentage => {
if !fields.insert(__FieldTag::__media_progress_percentage) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for media_progress_percentage",
));
}
struct __With(std::option::Option<f32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::F32> >::deserialize(deserializer).map(__With)
}
}
result.media_progress_percentage = map.next_value::<__With>()?.0;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "user-event-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::WriteUserEventRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__parent,
__user_event,
__write_async,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for WriteUserEventRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"parent" => Ok(__FieldTag::__parent),
"userEvent" => Ok(__FieldTag::__user_event),
"user_event" => Ok(__FieldTag::__user_event),
"writeAsync" => Ok(__FieldTag::__write_async),
"write_async" => Ok(__FieldTag::__write_async),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::WriteUserEventRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct WriteUserEventRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__user_event => {
if !fields.insert(__FieldTag::__user_event) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for user_event",
));
}
result.user_event =
map.next_value::<std::option::Option<crate::model::UserEvent>>()?;
}
__FieldTag::__write_async => {
if !fields.insert(__FieldTag::__write_async) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for write_async",
));
}
result.write_async = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "user-event-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::CollectUserEventRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__parent,
__user_event,
__uri,
__ets,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for CollectUserEventRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"parent" => Ok(__FieldTag::__parent),
"userEvent" => Ok(__FieldTag::__user_event),
"user_event" => Ok(__FieldTag::__user_event),
"uri" => Ok(__FieldTag::__uri),
"ets" => Ok(__FieldTag::__ets),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::CollectUserEventRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct CollectUserEventRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__user_event => {
if !fields.insert(__FieldTag::__user_event) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for user_event",
));
}
result.user_event = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__uri => {
if !fields.insert(__FieldTag::__uri) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for uri",
));
}
result.uri =
map.next_value::<std::option::Option<std::string::String>>()?;
}
__FieldTag::__ets => {
if !fields.insert(__FieldTag::__ets) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for ets",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.ets = map.next_value::<__With>()?.0;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "user-license-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::UserLicense {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__user_principal,
__user_profile,
__license_assignment_state,
__license_config,
__create_time,
__update_time,
__last_login_time,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for UserLicense")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"userPrincipal" => Ok(__FieldTag::__user_principal),
"user_principal" => Ok(__FieldTag::__user_principal),
"userProfile" => Ok(__FieldTag::__user_profile),
"user_profile" => Ok(__FieldTag::__user_profile),
"licenseAssignmentState" => Ok(__FieldTag::__license_assignment_state),
"license_assignment_state" => {
Ok(__FieldTag::__license_assignment_state)
}
"licenseConfig" => Ok(__FieldTag::__license_config),
"license_config" => Ok(__FieldTag::__license_config),
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"updateTime" => Ok(__FieldTag::__update_time),
"update_time" => Ok(__FieldTag::__update_time),
"lastLoginTime" => Ok(__FieldTag::__last_login_time),
"last_login_time" => Ok(__FieldTag::__last_login_time),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::UserLicense;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct UserLicense")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__user_principal => {
if !fields.insert(__FieldTag::__user_principal) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for user_principal",
));
}
result.user_principal = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__user_profile => {
if !fields.insert(__FieldTag::__user_profile) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for user_profile",
));
}
result.user_profile = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__license_assignment_state => {
if !fields.insert(__FieldTag::__license_assignment_state) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for license_assignment_state",
));
}
result.license_assignment_state = map
.next_value::<std::option::Option<
crate::model::user_license::LicenseAssignmentState,
>>()?
.unwrap_or_default();
}
__FieldTag::__license_config => {
if !fields.insert(__FieldTag::__license_config) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for license_config",
));
}
result.license_config = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__update_time => {
if !fields.insert(__FieldTag::__update_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_time",
));
}
result.update_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__last_login_time => {
if !fields.insert(__FieldTag::__last_login_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for last_login_time",
));
}
result.last_login_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "user-license-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ListUserLicensesRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__parent,
__page_size,
__page_token,
__filter,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ListUserLicensesRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"parent" => Ok(__FieldTag::__parent),
"pageSize" => Ok(__FieldTag::__page_size),
"page_size" => Ok(__FieldTag::__page_size),
"pageToken" => Ok(__FieldTag::__page_token),
"page_token" => Ok(__FieldTag::__page_token),
"filter" => Ok(__FieldTag::__filter),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListUserLicensesRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListUserLicensesRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__page_size => {
if !fields.insert(__FieldTag::__page_size) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_size",
));
}
struct __With(std::option::Option<i32>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
}
}
result.page_size = map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__page_token => {
if !fields.insert(__FieldTag::__page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for page_token",
));
}
result.page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__filter => {
if !fields.insert(__FieldTag::__filter) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for filter",
));
}
result.filter = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "user-license-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ListUserLicensesResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__user_licenses,
__next_page_token,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for ListUserLicensesResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"userLicenses" => Ok(__FieldTag::__user_licenses),
"user_licenses" => Ok(__FieldTag::__user_licenses),
"nextPageToken" => Ok(__FieldTag::__next_page_token),
"next_page_token" => Ok(__FieldTag::__next_page_token),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::ListUserLicensesResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct ListUserLicensesResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__user_licenses => {
if !fields.insert(__FieldTag::__user_licenses) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for user_licenses",
));
}
result.user_licenses = map.next_value::<std::option::Option<std::vec::Vec<crate::model::UserLicense>>>()?.unwrap_or_default();
}
__FieldTag::__next_page_token => {
if !fields.insert(__FieldTag::__next_page_token) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for next_page_token",
));
}
result.next_page_token = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "user-license-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::BatchUpdateUserLicensesRequest {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__inline_source,
__parent,
__delete_unassigned_user_licenses,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for BatchUpdateUserLicensesRequest")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"inlineSource" => Ok(__FieldTag::__inline_source),
"inline_source" => Ok(__FieldTag::__inline_source),
"parent" => Ok(__FieldTag::__parent),
"deleteUnassignedUserLicenses" => {
Ok(__FieldTag::__delete_unassigned_user_licenses)
}
"delete_unassigned_user_licenses" => {
Ok(__FieldTag::__delete_unassigned_user_licenses)
}
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::BatchUpdateUserLicensesRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BatchUpdateUserLicensesRequest")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__inline_source => {
if !fields.insert(__FieldTag::__inline_source) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for inline_source",
));
}
if result.source.is_some() {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for `source`, a oneof with full ID .google.cloud.discoveryengine.v1.BatchUpdateUserLicensesRequest.inline_source, latest field was inlineSource",
));
}
result.source = std::option::Option::Some(
crate::model::batch_update_user_licenses_request::Source::InlineSource(
map.next_value::<std::option::Option<std::boxed::Box<crate::model::batch_update_user_licenses_request::InlineSource>>>()?.unwrap_or_default()
),
);
}
__FieldTag::__parent => {
if !fields.insert(__FieldTag::__parent) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for parent",
));
}
result.parent = map
.next_value::<std::option::Option<std::string::String>>()?
.unwrap_or_default();
}
__FieldTag::__delete_unassigned_user_licenses => {
if !fields.insert(__FieldTag::__delete_unassigned_user_licenses) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for delete_unassigned_user_licenses",
));
}
result.delete_unassigned_user_licenses = map
.next_value::<std::option::Option<bool>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "user-license-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::batch_update_user_licenses_request::InlineSource {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__user_licenses,
__update_mask,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for InlineSource")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"userLicenses" => Ok(__FieldTag::__user_licenses),
"user_licenses" => Ok(__FieldTag::__user_licenses),
"updateMask" => Ok(__FieldTag::__update_mask),
"update_mask" => Ok(__FieldTag::__update_mask),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::batch_update_user_licenses_request::InlineSource;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct InlineSource")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__user_licenses => {
if !fields.insert(__FieldTag::__user_licenses) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for user_licenses",
));
}
result.user_licenses = map.next_value::<std::option::Option<std::vec::Vec<crate::model::UserLicense>>>()?.unwrap_or_default();
}
__FieldTag::__update_mask => {
if !fields.insert(__FieldTag::__update_mask) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_mask",
));
}
result.update_mask =
map.next_value::<std::option::Option<wkt::FieldMask>>()?;
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "user-license-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::BatchUpdateUserLicensesMetadata {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__create_time,
__update_time,
__success_count,
__failure_count,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for BatchUpdateUserLicensesMetadata")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"createTime" => Ok(__FieldTag::__create_time),
"create_time" => Ok(__FieldTag::__create_time),
"updateTime" => Ok(__FieldTag::__update_time),
"update_time" => Ok(__FieldTag::__update_time),
"successCount" => Ok(__FieldTag::__success_count),
"success_count" => Ok(__FieldTag::__success_count),
"failureCount" => Ok(__FieldTag::__failure_count),
"failure_count" => Ok(__FieldTag::__failure_count),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::BatchUpdateUserLicensesMetadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BatchUpdateUserLicensesMetadata")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__create_time => {
if !fields.insert(__FieldTag::__create_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for create_time",
));
}
result.create_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__update_time => {
if !fields.insert(__FieldTag::__update_time) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for update_time",
));
}
result.update_time =
map.next_value::<std::option::Option<wkt::Timestamp>>()?;
}
__FieldTag::__success_count => {
if !fields.insert(__FieldTag::__success_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for success_count",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.success_count =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::__failure_count => {
if !fields.insert(__FieldTag::__failure_count) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for failure_count",
));
}
struct __With(std::option::Option<i64>);
impl<'de> serde::de::Deserialize<'de> for __With {
fn deserialize<D>(
deserializer: D,
) -> std::result::Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
}
}
result.failure_count =
map.next_value::<__With>()?.0.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}
#[cfg(feature = "user-license-service")]
#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::BatchUpdateUserLicensesResponse {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(PartialEq, Eq, Hash)]
enum __FieldTag {
__user_licenses,
__error_samples,
Unknown(std::string::String),
}
impl<'de> serde::de::Deserialize<'de> for __FieldTag {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = __FieldTag;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("a field name for BatchUpdateUserLicensesResponse")
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
use std::result::Result::Ok;
use std::string::ToString;
match value {
"userLicenses" => Ok(__FieldTag::__user_licenses),
"user_licenses" => Ok(__FieldTag::__user_licenses),
"errorSamples" => Ok(__FieldTag::__error_samples),
"error_samples" => Ok(__FieldTag::__error_samples),
_ => Ok(__FieldTag::Unknown(value.to_string())),
}
}
}
deserializer.deserialize_identifier(Visitor)
}
}
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = super::BatchUpdateUserLicensesResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("struct BatchUpdateUserLicensesResponse")
}
fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
#[allow(unused_imports)]
use serde::de::Error;
use std::option::Option::Some;
let mut fields = std::collections::HashSet::new();
let mut result = Self::Value::new();
while let Some(tag) = map.next_key::<__FieldTag>()? {
#[allow(clippy::match_single_binding)]
match tag {
__FieldTag::__user_licenses => {
if !fields.insert(__FieldTag::__user_licenses) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for user_licenses",
));
}
result.user_licenses = map.next_value::<std::option::Option<std::vec::Vec<crate::model::UserLicense>>>()?.unwrap_or_default();
}
__FieldTag::__error_samples => {
if !fields.insert(__FieldTag::__error_samples) {
return std::result::Result::Err(A::Error::duplicate_field(
"multiple values for error_samples",
));
}
result.error_samples =
map.next_value::<std::option::Option<
std::vec::Vec<google_cloud_rpc::model::Status>,
>>()?
.unwrap_or_default();
}
__FieldTag::Unknown(key) => {
let value = map.next_value::<serde_json::Value>()?;
result._unknown_fields.insert(key, value);
}
}
}
std::result::Result::Ok(result)
}
}
deserializer.deserialize_any(Visitor)
}
}