risingwave_pb/
hummock.serde.rs

1use crate::hummock::*;
2impl serde::Serialize for BloomFilterType {
3    #[allow(deprecated)]
4    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5    where
6        S: serde::Serializer,
7    {
8        let variant = match self {
9            Self::BloomFilterUnspecified => "BLOOM_FILTER_UNSPECIFIED",
10            Self::Sstable => "SSTABLE",
11            Self::Blocked => "BLOCKED",
12        };
13        serializer.serialize_str(variant)
14    }
15}
16impl<'de> serde::Deserialize<'de> for BloomFilterType {
17    #[allow(deprecated)]
18    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
19    where
20        D: serde::Deserializer<'de>,
21    {
22        const FIELDS: &[&str] = &[
23            "BLOOM_FILTER_UNSPECIFIED",
24            "SSTABLE",
25            "BLOCKED",
26        ];
27
28        struct GeneratedVisitor;
29
30        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
31            type Value = BloomFilterType;
32
33            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
34                write!(formatter, "expected one of: {:?}", &FIELDS)
35            }
36
37            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
38            where
39                E: serde::de::Error,
40            {
41                i32::try_from(v)
42                    .ok()
43                    .and_then(|x| x.try_into().ok())
44                    .ok_or_else(|| {
45                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
46                    })
47            }
48
49            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
50            where
51                E: serde::de::Error,
52            {
53                i32::try_from(v)
54                    .ok()
55                    .and_then(|x| x.try_into().ok())
56                    .ok_or_else(|| {
57                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
58                    })
59            }
60
61            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
62            where
63                E: serde::de::Error,
64            {
65                match value {
66                    "BLOOM_FILTER_UNSPECIFIED" => Ok(BloomFilterType::BloomFilterUnspecified),
67                    "SSTABLE" => Ok(BloomFilterType::Sstable),
68                    "BLOCKED" => Ok(BloomFilterType::Blocked),
69                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
70                }
71            }
72        }
73        deserializer.deserialize_any(GeneratedVisitor)
74    }
75}
76impl serde::Serialize for BranchedObject {
77    #[allow(deprecated)]
78    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
79    where
80        S: serde::Serializer,
81    {
82        use serde::ser::SerializeStruct;
83        let mut len = 0;
84        if self.object_id != 0 {
85            len += 1;
86        }
87        if !self.sst_id.is_empty() {
88            len += 1;
89        }
90        if self.compaction_group_id != 0 {
91            len += 1;
92        }
93        let mut struct_ser = serializer.serialize_struct("hummock.BranchedObject", len)?;
94        if self.object_id != 0 {
95            #[allow(clippy::needless_borrow)]
96            #[allow(clippy::needless_borrows_for_generic_args)]
97            struct_ser.serialize_field("objectId", ToString::to_string(&self.object_id).as_str())?;
98        }
99        if !self.sst_id.is_empty() {
100            struct_ser.serialize_field("sstId", &self.sst_id.iter().map(ToString::to_string).collect::<Vec<_>>())?;
101        }
102        if self.compaction_group_id != 0 {
103            #[allow(clippy::needless_borrow)]
104            #[allow(clippy::needless_borrows_for_generic_args)]
105            struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
106        }
107        struct_ser.end()
108    }
109}
110impl<'de> serde::Deserialize<'de> for BranchedObject {
111    #[allow(deprecated)]
112    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
113    where
114        D: serde::Deserializer<'de>,
115    {
116        const FIELDS: &[&str] = &[
117            "object_id",
118            "objectId",
119            "sst_id",
120            "sstId",
121            "compaction_group_id",
122            "compactionGroupId",
123        ];
124
125        #[allow(clippy::enum_variant_names)]
126        enum GeneratedField {
127            ObjectId,
128            SstId,
129            CompactionGroupId,
130        }
131        impl<'de> serde::Deserialize<'de> for GeneratedField {
132            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
133            where
134                D: serde::Deserializer<'de>,
135            {
136                struct GeneratedVisitor;
137
138                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
139                    type Value = GeneratedField;
140
141                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
142                        write!(formatter, "expected one of: {:?}", &FIELDS)
143                    }
144
145                    #[allow(unused_variables)]
146                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
147                    where
148                        E: serde::de::Error,
149                    {
150                        match value {
151                            "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
152                            "sstId" | "sst_id" => Ok(GeneratedField::SstId),
153                            "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
154                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
155                        }
156                    }
157                }
158                deserializer.deserialize_identifier(GeneratedVisitor)
159            }
160        }
161        struct GeneratedVisitor;
162        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
163            type Value = BranchedObject;
164
165            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
166                formatter.write_str("struct hummock.BranchedObject")
167            }
168
169            fn visit_map<V>(self, mut map_: V) -> std::result::Result<BranchedObject, V::Error>
170                where
171                    V: serde::de::MapAccess<'de>,
172            {
173                let mut object_id__ = None;
174                let mut sst_id__ = None;
175                let mut compaction_group_id__ = None;
176                while let Some(k) = map_.next_key()? {
177                    match k {
178                        GeneratedField::ObjectId => {
179                            if object_id__.is_some() {
180                                return Err(serde::de::Error::duplicate_field("objectId"));
181                            }
182                            object_id__ = 
183                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
184                            ;
185                        }
186                        GeneratedField::SstId => {
187                            if sst_id__.is_some() {
188                                return Err(serde::de::Error::duplicate_field("sstId"));
189                            }
190                            sst_id__ = 
191                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
192                                    .into_iter().map(|x| x.0).collect())
193                            ;
194                        }
195                        GeneratedField::CompactionGroupId => {
196                            if compaction_group_id__.is_some() {
197                                return Err(serde::de::Error::duplicate_field("compactionGroupId"));
198                            }
199                            compaction_group_id__ = 
200                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
201                            ;
202                        }
203                    }
204                }
205                Ok(BranchedObject {
206                    object_id: object_id__.unwrap_or_default(),
207                    sst_id: sst_id__.unwrap_or_default(),
208                    compaction_group_id: compaction_group_id__.unwrap_or_default(),
209                })
210            }
211        }
212        deserializer.deserialize_struct("hummock.BranchedObject", FIELDS, GeneratedVisitor)
213    }
214}
215impl serde::Serialize for CancelCompactTask {
216    #[allow(deprecated)]
217    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
218    where
219        S: serde::Serializer,
220    {
221        use serde::ser::SerializeStruct;
222        let mut len = 0;
223        if self.context_id != 0 {
224            len += 1;
225        }
226        if self.task_id != 0 {
227            len += 1;
228        }
229        let mut struct_ser = serializer.serialize_struct("hummock.CancelCompactTask", len)?;
230        if self.context_id != 0 {
231            struct_ser.serialize_field("contextId", &self.context_id)?;
232        }
233        if self.task_id != 0 {
234            #[allow(clippy::needless_borrow)]
235            #[allow(clippy::needless_borrows_for_generic_args)]
236            struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
237        }
238        struct_ser.end()
239    }
240}
241impl<'de> serde::Deserialize<'de> for CancelCompactTask {
242    #[allow(deprecated)]
243    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
244    where
245        D: serde::Deserializer<'de>,
246    {
247        const FIELDS: &[&str] = &[
248            "context_id",
249            "contextId",
250            "task_id",
251            "taskId",
252        ];
253
254        #[allow(clippy::enum_variant_names)]
255        enum GeneratedField {
256            ContextId,
257            TaskId,
258        }
259        impl<'de> serde::Deserialize<'de> for GeneratedField {
260            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
261            where
262                D: serde::Deserializer<'de>,
263            {
264                struct GeneratedVisitor;
265
266                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
267                    type Value = GeneratedField;
268
269                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
270                        write!(formatter, "expected one of: {:?}", &FIELDS)
271                    }
272
273                    #[allow(unused_variables)]
274                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
275                    where
276                        E: serde::de::Error,
277                    {
278                        match value {
279                            "contextId" | "context_id" => Ok(GeneratedField::ContextId),
280                            "taskId" | "task_id" => Ok(GeneratedField::TaskId),
281                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
282                        }
283                    }
284                }
285                deserializer.deserialize_identifier(GeneratedVisitor)
286            }
287        }
288        struct GeneratedVisitor;
289        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
290            type Value = CancelCompactTask;
291
292            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
293                formatter.write_str("struct hummock.CancelCompactTask")
294            }
295
296            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCompactTask, V::Error>
297                where
298                    V: serde::de::MapAccess<'de>,
299            {
300                let mut context_id__ = None;
301                let mut task_id__ = None;
302                while let Some(k) = map_.next_key()? {
303                    match k {
304                        GeneratedField::ContextId => {
305                            if context_id__.is_some() {
306                                return Err(serde::de::Error::duplicate_field("contextId"));
307                            }
308                            context_id__ = 
309                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
310                            ;
311                        }
312                        GeneratedField::TaskId => {
313                            if task_id__.is_some() {
314                                return Err(serde::de::Error::duplicate_field("taskId"));
315                            }
316                            task_id__ = 
317                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
318                            ;
319                        }
320                    }
321                }
322                Ok(CancelCompactTask {
323                    context_id: context_id__.unwrap_or_default(),
324                    task_id: task_id__.unwrap_or_default(),
325                })
326            }
327        }
328        deserializer.deserialize_struct("hummock.CancelCompactTask", FIELDS, GeneratedVisitor)
329    }
330}
331impl serde::Serialize for CancelCompactTaskRequest {
332    #[allow(deprecated)]
333    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
334    where
335        S: serde::Serializer,
336    {
337        use serde::ser::SerializeStruct;
338        let mut len = 0;
339        if self.task_id != 0 {
340            len += 1;
341        }
342        if self.task_status != 0 {
343            len += 1;
344        }
345        let mut struct_ser = serializer.serialize_struct("hummock.CancelCompactTaskRequest", len)?;
346        if self.task_id != 0 {
347            #[allow(clippy::needless_borrow)]
348            #[allow(clippy::needless_borrows_for_generic_args)]
349            struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
350        }
351        if self.task_status != 0 {
352            let v = compact_task::TaskStatus::try_from(self.task_status)
353                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.task_status)))?;
354            struct_ser.serialize_field("taskStatus", &v)?;
355        }
356        struct_ser.end()
357    }
358}
359impl<'de> serde::Deserialize<'de> for CancelCompactTaskRequest {
360    #[allow(deprecated)]
361    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
362    where
363        D: serde::Deserializer<'de>,
364    {
365        const FIELDS: &[&str] = &[
366            "task_id",
367            "taskId",
368            "task_status",
369            "taskStatus",
370        ];
371
372        #[allow(clippy::enum_variant_names)]
373        enum GeneratedField {
374            TaskId,
375            TaskStatus,
376        }
377        impl<'de> serde::Deserialize<'de> for GeneratedField {
378            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
379            where
380                D: serde::Deserializer<'de>,
381            {
382                struct GeneratedVisitor;
383
384                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
385                    type Value = GeneratedField;
386
387                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
388                        write!(formatter, "expected one of: {:?}", &FIELDS)
389                    }
390
391                    #[allow(unused_variables)]
392                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
393                    where
394                        E: serde::de::Error,
395                    {
396                        match value {
397                            "taskId" | "task_id" => Ok(GeneratedField::TaskId),
398                            "taskStatus" | "task_status" => Ok(GeneratedField::TaskStatus),
399                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
400                        }
401                    }
402                }
403                deserializer.deserialize_identifier(GeneratedVisitor)
404            }
405        }
406        struct GeneratedVisitor;
407        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
408            type Value = CancelCompactTaskRequest;
409
410            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
411                formatter.write_str("struct hummock.CancelCompactTaskRequest")
412            }
413
414            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCompactTaskRequest, V::Error>
415                where
416                    V: serde::de::MapAccess<'de>,
417            {
418                let mut task_id__ = None;
419                let mut task_status__ = None;
420                while let Some(k) = map_.next_key()? {
421                    match k {
422                        GeneratedField::TaskId => {
423                            if task_id__.is_some() {
424                                return Err(serde::de::Error::duplicate_field("taskId"));
425                            }
426                            task_id__ = 
427                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
428                            ;
429                        }
430                        GeneratedField::TaskStatus => {
431                            if task_status__.is_some() {
432                                return Err(serde::de::Error::duplicate_field("taskStatus"));
433                            }
434                            task_status__ = Some(map_.next_value::<compact_task::TaskStatus>()? as i32);
435                        }
436                    }
437                }
438                Ok(CancelCompactTaskRequest {
439                    task_id: task_id__.unwrap_or_default(),
440                    task_status: task_status__.unwrap_or_default(),
441                })
442            }
443        }
444        deserializer.deserialize_struct("hummock.CancelCompactTaskRequest", FIELDS, GeneratedVisitor)
445    }
446}
447impl serde::Serialize for CancelCompactTaskResponse {
448    #[allow(deprecated)]
449    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
450    where
451        S: serde::Serializer,
452    {
453        use serde::ser::SerializeStruct;
454        let mut len = 0;
455        if self.ret {
456            len += 1;
457        }
458        let mut struct_ser = serializer.serialize_struct("hummock.CancelCompactTaskResponse", len)?;
459        if self.ret {
460            struct_ser.serialize_field("ret", &self.ret)?;
461        }
462        struct_ser.end()
463    }
464}
465impl<'de> serde::Deserialize<'de> for CancelCompactTaskResponse {
466    #[allow(deprecated)]
467    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
468    where
469        D: serde::Deserializer<'de>,
470    {
471        const FIELDS: &[&str] = &[
472            "ret",
473        ];
474
475        #[allow(clippy::enum_variant_names)]
476        enum GeneratedField {
477            Ret,
478        }
479        impl<'de> serde::Deserialize<'de> for GeneratedField {
480            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
481            where
482                D: serde::Deserializer<'de>,
483            {
484                struct GeneratedVisitor;
485
486                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
487                    type Value = GeneratedField;
488
489                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
490                        write!(formatter, "expected one of: {:?}", &FIELDS)
491                    }
492
493                    #[allow(unused_variables)]
494                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
495                    where
496                        E: serde::de::Error,
497                    {
498                        match value {
499                            "ret" => Ok(GeneratedField::Ret),
500                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
501                        }
502                    }
503                }
504                deserializer.deserialize_identifier(GeneratedVisitor)
505            }
506        }
507        struct GeneratedVisitor;
508        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
509            type Value = CancelCompactTaskResponse;
510
511            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
512                formatter.write_str("struct hummock.CancelCompactTaskResponse")
513            }
514
515            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCompactTaskResponse, V::Error>
516                where
517                    V: serde::de::MapAccess<'de>,
518            {
519                let mut ret__ = None;
520                while let Some(k) = map_.next_key()? {
521                    match k {
522                        GeneratedField::Ret => {
523                            if ret__.is_some() {
524                                return Err(serde::de::Error::duplicate_field("ret"));
525                            }
526                            ret__ = Some(map_.next_value()?);
527                        }
528                    }
529                }
530                Ok(CancelCompactTaskResponse {
531                    ret: ret__.unwrap_or_default(),
532                })
533            }
534        }
535        deserializer.deserialize_struct("hummock.CancelCompactTaskResponse", FIELDS, GeneratedVisitor)
536    }
537}
538impl serde::Serialize for CompactStatus {
539    #[allow(deprecated)]
540    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
541    where
542        S: serde::Serializer,
543    {
544        use serde::ser::SerializeStruct;
545        let mut len = 0;
546        if self.compaction_group_id != 0 {
547            len += 1;
548        }
549        if !self.level_handlers.is_empty() {
550            len += 1;
551        }
552        let mut struct_ser = serializer.serialize_struct("hummock.CompactStatus", len)?;
553        if self.compaction_group_id != 0 {
554            #[allow(clippy::needless_borrow)]
555            #[allow(clippy::needless_borrows_for_generic_args)]
556            struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
557        }
558        if !self.level_handlers.is_empty() {
559            struct_ser.serialize_field("levelHandlers", &self.level_handlers)?;
560        }
561        struct_ser.end()
562    }
563}
564impl<'de> serde::Deserialize<'de> for CompactStatus {
565    #[allow(deprecated)]
566    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
567    where
568        D: serde::Deserializer<'de>,
569    {
570        const FIELDS: &[&str] = &[
571            "compaction_group_id",
572            "compactionGroupId",
573            "level_handlers",
574            "levelHandlers",
575        ];
576
577        #[allow(clippy::enum_variant_names)]
578        enum GeneratedField {
579            CompactionGroupId,
580            LevelHandlers,
581        }
582        impl<'de> serde::Deserialize<'de> for GeneratedField {
583            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
584            where
585                D: serde::Deserializer<'de>,
586            {
587                struct GeneratedVisitor;
588
589                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
590                    type Value = GeneratedField;
591
592                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
593                        write!(formatter, "expected one of: {:?}", &FIELDS)
594                    }
595
596                    #[allow(unused_variables)]
597                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
598                    where
599                        E: serde::de::Error,
600                    {
601                        match value {
602                            "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
603                            "levelHandlers" | "level_handlers" => Ok(GeneratedField::LevelHandlers),
604                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
605                        }
606                    }
607                }
608                deserializer.deserialize_identifier(GeneratedVisitor)
609            }
610        }
611        struct GeneratedVisitor;
612        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
613            type Value = CompactStatus;
614
615            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
616                formatter.write_str("struct hummock.CompactStatus")
617            }
618
619            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactStatus, V::Error>
620                where
621                    V: serde::de::MapAccess<'de>,
622            {
623                let mut compaction_group_id__ = None;
624                let mut level_handlers__ = None;
625                while let Some(k) = map_.next_key()? {
626                    match k {
627                        GeneratedField::CompactionGroupId => {
628                            if compaction_group_id__.is_some() {
629                                return Err(serde::de::Error::duplicate_field("compactionGroupId"));
630                            }
631                            compaction_group_id__ = 
632                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
633                            ;
634                        }
635                        GeneratedField::LevelHandlers => {
636                            if level_handlers__.is_some() {
637                                return Err(serde::de::Error::duplicate_field("levelHandlers"));
638                            }
639                            level_handlers__ = Some(map_.next_value()?);
640                        }
641                    }
642                }
643                Ok(CompactStatus {
644                    compaction_group_id: compaction_group_id__.unwrap_or_default(),
645                    level_handlers: level_handlers__.unwrap_or_default(),
646                })
647            }
648        }
649        deserializer.deserialize_struct("hummock.CompactStatus", FIELDS, GeneratedVisitor)
650    }
651}
652impl serde::Serialize for CompactTask {
653    #[allow(deprecated)]
654    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
655    where
656        S: serde::Serializer,
657    {
658        use serde::ser::SerializeStruct;
659        let mut len = 0;
660        if !self.input_ssts.is_empty() {
661            len += 1;
662        }
663        if !self.splits.is_empty() {
664            len += 1;
665        }
666        if !self.sorted_output_ssts.is_empty() {
667            len += 1;
668        }
669        if self.task_id != 0 {
670            len += 1;
671        }
672        if self.target_level != 0 {
673            len += 1;
674        }
675        if self.gc_delete_keys {
676            len += 1;
677        }
678        if self.base_level != 0 {
679            len += 1;
680        }
681        if self.task_status != 0 {
682            len += 1;
683        }
684        if self.compaction_group_id != 0 {
685            len += 1;
686        }
687        if !self.existing_table_ids.is_empty() {
688            len += 1;
689        }
690        if self.compression_algorithm != 0 {
691            len += 1;
692        }
693        if self.target_file_size != 0 {
694            len += 1;
695        }
696        if self.compaction_filter_mask != 0 {
697            len += 1;
698        }
699        if !self.table_options.is_empty() {
700            len += 1;
701        }
702        if self.current_epoch_time != 0 {
703            len += 1;
704        }
705        if self.target_sub_level_id != 0 {
706            len += 1;
707        }
708        if self.task_type != 0 {
709            len += 1;
710        }
711        if self.split_by_state_table {
712            len += 1;
713        }
714        if self.split_weight_by_vnode != 0 {
715            len += 1;
716        }
717        if !self.table_vnode_partition.is_empty() {
718            len += 1;
719        }
720        if !self.table_watermarks.is_empty() {
721            len += 1;
722        }
723        if !self.table_schemas.is_empty() {
724            len += 1;
725        }
726        if self.max_sub_compaction != 0 {
727            len += 1;
728        }
729        if self.compaction_group_version_id != 0 {
730            len += 1;
731        }
732        let mut struct_ser = serializer.serialize_struct("hummock.CompactTask", len)?;
733        if !self.input_ssts.is_empty() {
734            struct_ser.serialize_field("inputSsts", &self.input_ssts)?;
735        }
736        if !self.splits.is_empty() {
737            struct_ser.serialize_field("splits", &self.splits)?;
738        }
739        if !self.sorted_output_ssts.is_empty() {
740            struct_ser.serialize_field("sortedOutputSsts", &self.sorted_output_ssts)?;
741        }
742        if self.task_id != 0 {
743            #[allow(clippy::needless_borrow)]
744            #[allow(clippy::needless_borrows_for_generic_args)]
745            struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
746        }
747        if self.target_level != 0 {
748            struct_ser.serialize_field("targetLevel", &self.target_level)?;
749        }
750        if self.gc_delete_keys {
751            struct_ser.serialize_field("gcDeleteKeys", &self.gc_delete_keys)?;
752        }
753        if self.base_level != 0 {
754            struct_ser.serialize_field("baseLevel", &self.base_level)?;
755        }
756        if self.task_status != 0 {
757            let v = compact_task::TaskStatus::try_from(self.task_status)
758                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.task_status)))?;
759            struct_ser.serialize_field("taskStatus", &v)?;
760        }
761        if self.compaction_group_id != 0 {
762            #[allow(clippy::needless_borrow)]
763            #[allow(clippy::needless_borrows_for_generic_args)]
764            struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
765        }
766        if !self.existing_table_ids.is_empty() {
767            struct_ser.serialize_field("existingTableIds", &self.existing_table_ids)?;
768        }
769        if self.compression_algorithm != 0 {
770            struct_ser.serialize_field("compressionAlgorithm", &self.compression_algorithm)?;
771        }
772        if self.target_file_size != 0 {
773            #[allow(clippy::needless_borrow)]
774            #[allow(clippy::needless_borrows_for_generic_args)]
775            struct_ser.serialize_field("targetFileSize", ToString::to_string(&self.target_file_size).as_str())?;
776        }
777        if self.compaction_filter_mask != 0 {
778            struct_ser.serialize_field("compactionFilterMask", &self.compaction_filter_mask)?;
779        }
780        if !self.table_options.is_empty() {
781            struct_ser.serialize_field("tableOptions", &self.table_options)?;
782        }
783        if self.current_epoch_time != 0 {
784            #[allow(clippy::needless_borrow)]
785            #[allow(clippy::needless_borrows_for_generic_args)]
786            struct_ser.serialize_field("currentEpochTime", ToString::to_string(&self.current_epoch_time).as_str())?;
787        }
788        if self.target_sub_level_id != 0 {
789            #[allow(clippy::needless_borrow)]
790            #[allow(clippy::needless_borrows_for_generic_args)]
791            struct_ser.serialize_field("targetSubLevelId", ToString::to_string(&self.target_sub_level_id).as_str())?;
792        }
793        if self.task_type != 0 {
794            let v = compact_task::TaskType::try_from(self.task_type)
795                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.task_type)))?;
796            struct_ser.serialize_field("taskType", &v)?;
797        }
798        if self.split_by_state_table {
799            struct_ser.serialize_field("splitByStateTable", &self.split_by_state_table)?;
800        }
801        if self.split_weight_by_vnode != 0 {
802            struct_ser.serialize_field("splitWeightByVnode", &self.split_weight_by_vnode)?;
803        }
804        if !self.table_vnode_partition.is_empty() {
805            struct_ser.serialize_field("tableVnodePartition", &self.table_vnode_partition)?;
806        }
807        if !self.table_watermarks.is_empty() {
808            struct_ser.serialize_field("tableWatermarks", &self.table_watermarks)?;
809        }
810        if !self.table_schemas.is_empty() {
811            struct_ser.serialize_field("tableSchemas", &self.table_schemas)?;
812        }
813        if self.max_sub_compaction != 0 {
814            struct_ser.serialize_field("maxSubCompaction", &self.max_sub_compaction)?;
815        }
816        if self.compaction_group_version_id != 0 {
817            #[allow(clippy::needless_borrow)]
818            #[allow(clippy::needless_borrows_for_generic_args)]
819            struct_ser.serialize_field("compactionGroupVersionId", ToString::to_string(&self.compaction_group_version_id).as_str())?;
820        }
821        struct_ser.end()
822    }
823}
824impl<'de> serde::Deserialize<'de> for CompactTask {
825    #[allow(deprecated)]
826    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
827    where
828        D: serde::Deserializer<'de>,
829    {
830        const FIELDS: &[&str] = &[
831            "input_ssts",
832            "inputSsts",
833            "splits",
834            "sorted_output_ssts",
835            "sortedOutputSsts",
836            "task_id",
837            "taskId",
838            "target_level",
839            "targetLevel",
840            "gc_delete_keys",
841            "gcDeleteKeys",
842            "base_level",
843            "baseLevel",
844            "task_status",
845            "taskStatus",
846            "compaction_group_id",
847            "compactionGroupId",
848            "existing_table_ids",
849            "existingTableIds",
850            "compression_algorithm",
851            "compressionAlgorithm",
852            "target_file_size",
853            "targetFileSize",
854            "compaction_filter_mask",
855            "compactionFilterMask",
856            "table_options",
857            "tableOptions",
858            "current_epoch_time",
859            "currentEpochTime",
860            "target_sub_level_id",
861            "targetSubLevelId",
862            "task_type",
863            "taskType",
864            "split_by_state_table",
865            "splitByStateTable",
866            "split_weight_by_vnode",
867            "splitWeightByVnode",
868            "table_vnode_partition",
869            "tableVnodePartition",
870            "table_watermarks",
871            "tableWatermarks",
872            "table_schemas",
873            "tableSchemas",
874            "max_sub_compaction",
875            "maxSubCompaction",
876            "compaction_group_version_id",
877            "compactionGroupVersionId",
878        ];
879
880        #[allow(clippy::enum_variant_names)]
881        enum GeneratedField {
882            InputSsts,
883            Splits,
884            SortedOutputSsts,
885            TaskId,
886            TargetLevel,
887            GcDeleteKeys,
888            BaseLevel,
889            TaskStatus,
890            CompactionGroupId,
891            ExistingTableIds,
892            CompressionAlgorithm,
893            TargetFileSize,
894            CompactionFilterMask,
895            TableOptions,
896            CurrentEpochTime,
897            TargetSubLevelId,
898            TaskType,
899            SplitByStateTable,
900            SplitWeightByVnode,
901            TableVnodePartition,
902            TableWatermarks,
903            TableSchemas,
904            MaxSubCompaction,
905            CompactionGroupVersionId,
906        }
907        impl<'de> serde::Deserialize<'de> for GeneratedField {
908            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
909            where
910                D: serde::Deserializer<'de>,
911            {
912                struct GeneratedVisitor;
913
914                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
915                    type Value = GeneratedField;
916
917                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
918                        write!(formatter, "expected one of: {:?}", &FIELDS)
919                    }
920
921                    #[allow(unused_variables)]
922                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
923                    where
924                        E: serde::de::Error,
925                    {
926                        match value {
927                            "inputSsts" | "input_ssts" => Ok(GeneratedField::InputSsts),
928                            "splits" => Ok(GeneratedField::Splits),
929                            "sortedOutputSsts" | "sorted_output_ssts" => Ok(GeneratedField::SortedOutputSsts),
930                            "taskId" | "task_id" => Ok(GeneratedField::TaskId),
931                            "targetLevel" | "target_level" => Ok(GeneratedField::TargetLevel),
932                            "gcDeleteKeys" | "gc_delete_keys" => Ok(GeneratedField::GcDeleteKeys),
933                            "baseLevel" | "base_level" => Ok(GeneratedField::BaseLevel),
934                            "taskStatus" | "task_status" => Ok(GeneratedField::TaskStatus),
935                            "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
936                            "existingTableIds" | "existing_table_ids" => Ok(GeneratedField::ExistingTableIds),
937                            "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
938                            "targetFileSize" | "target_file_size" => Ok(GeneratedField::TargetFileSize),
939                            "compactionFilterMask" | "compaction_filter_mask" => Ok(GeneratedField::CompactionFilterMask),
940                            "tableOptions" | "table_options" => Ok(GeneratedField::TableOptions),
941                            "currentEpochTime" | "current_epoch_time" => Ok(GeneratedField::CurrentEpochTime),
942                            "targetSubLevelId" | "target_sub_level_id" => Ok(GeneratedField::TargetSubLevelId),
943                            "taskType" | "task_type" => Ok(GeneratedField::TaskType),
944                            "splitByStateTable" | "split_by_state_table" => Ok(GeneratedField::SplitByStateTable),
945                            "splitWeightByVnode" | "split_weight_by_vnode" => Ok(GeneratedField::SplitWeightByVnode),
946                            "tableVnodePartition" | "table_vnode_partition" => Ok(GeneratedField::TableVnodePartition),
947                            "tableWatermarks" | "table_watermarks" => Ok(GeneratedField::TableWatermarks),
948                            "tableSchemas" | "table_schemas" => Ok(GeneratedField::TableSchemas),
949                            "maxSubCompaction" | "max_sub_compaction" => Ok(GeneratedField::MaxSubCompaction),
950                            "compactionGroupVersionId" | "compaction_group_version_id" => Ok(GeneratedField::CompactionGroupVersionId),
951                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
952                        }
953                    }
954                }
955                deserializer.deserialize_identifier(GeneratedVisitor)
956            }
957        }
958        struct GeneratedVisitor;
959        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
960            type Value = CompactTask;
961
962            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
963                formatter.write_str("struct hummock.CompactTask")
964            }
965
966            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactTask, V::Error>
967                where
968                    V: serde::de::MapAccess<'de>,
969            {
970                let mut input_ssts__ = None;
971                let mut splits__ = None;
972                let mut sorted_output_ssts__ = None;
973                let mut task_id__ = None;
974                let mut target_level__ = None;
975                let mut gc_delete_keys__ = None;
976                let mut base_level__ = None;
977                let mut task_status__ = None;
978                let mut compaction_group_id__ = None;
979                let mut existing_table_ids__ = None;
980                let mut compression_algorithm__ = None;
981                let mut target_file_size__ = None;
982                let mut compaction_filter_mask__ = None;
983                let mut table_options__ = None;
984                let mut current_epoch_time__ = None;
985                let mut target_sub_level_id__ = None;
986                let mut task_type__ = None;
987                let mut split_by_state_table__ = None;
988                let mut split_weight_by_vnode__ = None;
989                let mut table_vnode_partition__ = None;
990                let mut table_watermarks__ = None;
991                let mut table_schemas__ = None;
992                let mut max_sub_compaction__ = None;
993                let mut compaction_group_version_id__ = None;
994                while let Some(k) = map_.next_key()? {
995                    match k {
996                        GeneratedField::InputSsts => {
997                            if input_ssts__.is_some() {
998                                return Err(serde::de::Error::duplicate_field("inputSsts"));
999                            }
1000                            input_ssts__ = Some(map_.next_value()?);
1001                        }
1002                        GeneratedField::Splits => {
1003                            if splits__.is_some() {
1004                                return Err(serde::de::Error::duplicate_field("splits"));
1005                            }
1006                            splits__ = Some(map_.next_value()?);
1007                        }
1008                        GeneratedField::SortedOutputSsts => {
1009                            if sorted_output_ssts__.is_some() {
1010                                return Err(serde::de::Error::duplicate_field("sortedOutputSsts"));
1011                            }
1012                            sorted_output_ssts__ = Some(map_.next_value()?);
1013                        }
1014                        GeneratedField::TaskId => {
1015                            if task_id__.is_some() {
1016                                return Err(serde::de::Error::duplicate_field("taskId"));
1017                            }
1018                            task_id__ = 
1019                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1020                            ;
1021                        }
1022                        GeneratedField::TargetLevel => {
1023                            if target_level__.is_some() {
1024                                return Err(serde::de::Error::duplicate_field("targetLevel"));
1025                            }
1026                            target_level__ = 
1027                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1028                            ;
1029                        }
1030                        GeneratedField::GcDeleteKeys => {
1031                            if gc_delete_keys__.is_some() {
1032                                return Err(serde::de::Error::duplicate_field("gcDeleteKeys"));
1033                            }
1034                            gc_delete_keys__ = Some(map_.next_value()?);
1035                        }
1036                        GeneratedField::BaseLevel => {
1037                            if base_level__.is_some() {
1038                                return Err(serde::de::Error::duplicate_field("baseLevel"));
1039                            }
1040                            base_level__ = 
1041                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1042                            ;
1043                        }
1044                        GeneratedField::TaskStatus => {
1045                            if task_status__.is_some() {
1046                                return Err(serde::de::Error::duplicate_field("taskStatus"));
1047                            }
1048                            task_status__ = Some(map_.next_value::<compact_task::TaskStatus>()? as i32);
1049                        }
1050                        GeneratedField::CompactionGroupId => {
1051                            if compaction_group_id__.is_some() {
1052                                return Err(serde::de::Error::duplicate_field("compactionGroupId"));
1053                            }
1054                            compaction_group_id__ = 
1055                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1056                            ;
1057                        }
1058                        GeneratedField::ExistingTableIds => {
1059                            if existing_table_ids__.is_some() {
1060                                return Err(serde::de::Error::duplicate_field("existingTableIds"));
1061                            }
1062                            existing_table_ids__ = 
1063                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1064                                    .into_iter().map(|x| x.0).collect())
1065                            ;
1066                        }
1067                        GeneratedField::CompressionAlgorithm => {
1068                            if compression_algorithm__.is_some() {
1069                                return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
1070                            }
1071                            compression_algorithm__ = 
1072                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1073                            ;
1074                        }
1075                        GeneratedField::TargetFileSize => {
1076                            if target_file_size__.is_some() {
1077                                return Err(serde::de::Error::duplicate_field("targetFileSize"));
1078                            }
1079                            target_file_size__ = 
1080                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1081                            ;
1082                        }
1083                        GeneratedField::CompactionFilterMask => {
1084                            if compaction_filter_mask__.is_some() {
1085                                return Err(serde::de::Error::duplicate_field("compactionFilterMask"));
1086                            }
1087                            compaction_filter_mask__ = 
1088                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1089                            ;
1090                        }
1091                        GeneratedField::TableOptions => {
1092                            if table_options__.is_some() {
1093                                return Err(serde::de::Error::duplicate_field("tableOptions"));
1094                            }
1095                            table_options__ = Some(
1096                                map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1097                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
1098                            );
1099                        }
1100                        GeneratedField::CurrentEpochTime => {
1101                            if current_epoch_time__.is_some() {
1102                                return Err(serde::de::Error::duplicate_field("currentEpochTime"));
1103                            }
1104                            current_epoch_time__ = 
1105                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1106                            ;
1107                        }
1108                        GeneratedField::TargetSubLevelId => {
1109                            if target_sub_level_id__.is_some() {
1110                                return Err(serde::de::Error::duplicate_field("targetSubLevelId"));
1111                            }
1112                            target_sub_level_id__ = 
1113                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1114                            ;
1115                        }
1116                        GeneratedField::TaskType => {
1117                            if task_type__.is_some() {
1118                                return Err(serde::de::Error::duplicate_field("taskType"));
1119                            }
1120                            task_type__ = Some(map_.next_value::<compact_task::TaskType>()? as i32);
1121                        }
1122                        GeneratedField::SplitByStateTable => {
1123                            if split_by_state_table__.is_some() {
1124                                return Err(serde::de::Error::duplicate_field("splitByStateTable"));
1125                            }
1126                            split_by_state_table__ = Some(map_.next_value()?);
1127                        }
1128                        GeneratedField::SplitWeightByVnode => {
1129                            if split_weight_by_vnode__.is_some() {
1130                                return Err(serde::de::Error::duplicate_field("splitWeightByVnode"));
1131                            }
1132                            split_weight_by_vnode__ = 
1133                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1134                            ;
1135                        }
1136                        GeneratedField::TableVnodePartition => {
1137                            if table_vnode_partition__.is_some() {
1138                                return Err(serde::de::Error::duplicate_field("tableVnodePartition"));
1139                            }
1140                            table_vnode_partition__ = Some(
1141                                map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
1142                                    .into_iter().map(|(k,v)| (k.0, v.0)).collect()
1143                            );
1144                        }
1145                        GeneratedField::TableWatermarks => {
1146                            if table_watermarks__.is_some() {
1147                                return Err(serde::de::Error::duplicate_field("tableWatermarks"));
1148                            }
1149                            table_watermarks__ = Some(
1150                                map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1151                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
1152                            );
1153                        }
1154                        GeneratedField::TableSchemas => {
1155                            if table_schemas__.is_some() {
1156                                return Err(serde::de::Error::duplicate_field("tableSchemas"));
1157                            }
1158                            table_schemas__ = Some(
1159                                map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1160                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
1161                            );
1162                        }
1163                        GeneratedField::MaxSubCompaction => {
1164                            if max_sub_compaction__.is_some() {
1165                                return Err(serde::de::Error::duplicate_field("maxSubCompaction"));
1166                            }
1167                            max_sub_compaction__ = 
1168                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1169                            ;
1170                        }
1171                        GeneratedField::CompactionGroupVersionId => {
1172                            if compaction_group_version_id__.is_some() {
1173                                return Err(serde::de::Error::duplicate_field("compactionGroupVersionId"));
1174                            }
1175                            compaction_group_version_id__ = 
1176                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1177                            ;
1178                        }
1179                    }
1180                }
1181                Ok(CompactTask {
1182                    input_ssts: input_ssts__.unwrap_or_default(),
1183                    splits: splits__.unwrap_or_default(),
1184                    sorted_output_ssts: sorted_output_ssts__.unwrap_or_default(),
1185                    task_id: task_id__.unwrap_or_default(),
1186                    target_level: target_level__.unwrap_or_default(),
1187                    gc_delete_keys: gc_delete_keys__.unwrap_or_default(),
1188                    base_level: base_level__.unwrap_or_default(),
1189                    task_status: task_status__.unwrap_or_default(),
1190                    compaction_group_id: compaction_group_id__.unwrap_or_default(),
1191                    existing_table_ids: existing_table_ids__.unwrap_or_default(),
1192                    compression_algorithm: compression_algorithm__.unwrap_or_default(),
1193                    target_file_size: target_file_size__.unwrap_or_default(),
1194                    compaction_filter_mask: compaction_filter_mask__.unwrap_or_default(),
1195                    table_options: table_options__.unwrap_or_default(),
1196                    current_epoch_time: current_epoch_time__.unwrap_or_default(),
1197                    target_sub_level_id: target_sub_level_id__.unwrap_or_default(),
1198                    task_type: task_type__.unwrap_or_default(),
1199                    split_by_state_table: split_by_state_table__.unwrap_or_default(),
1200                    split_weight_by_vnode: split_weight_by_vnode__.unwrap_or_default(),
1201                    table_vnode_partition: table_vnode_partition__.unwrap_or_default(),
1202                    table_watermarks: table_watermarks__.unwrap_or_default(),
1203                    table_schemas: table_schemas__.unwrap_or_default(),
1204                    max_sub_compaction: max_sub_compaction__.unwrap_or_default(),
1205                    compaction_group_version_id: compaction_group_version_id__.unwrap_or_default(),
1206                })
1207            }
1208        }
1209        deserializer.deserialize_struct("hummock.CompactTask", FIELDS, GeneratedVisitor)
1210    }
1211}
1212impl serde::Serialize for compact_task::TaskStatus {
1213    #[allow(deprecated)]
1214    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1215    where
1216        S: serde::Serializer,
1217    {
1218        let variant = match self {
1219            Self::Unspecified => "UNSPECIFIED",
1220            Self::Pending => "PENDING",
1221            Self::Success => "SUCCESS",
1222            Self::HeartbeatCanceled => "HEARTBEAT_CANCELED",
1223            Self::NoAvailMemoryResourceCanceled => "NO_AVAIL_MEMORY_RESOURCE_CANCELED",
1224            Self::AssignFailCanceled => "ASSIGN_FAIL_CANCELED",
1225            Self::SendFailCanceled => "SEND_FAIL_CANCELED",
1226            Self::ManualCanceled => "MANUAL_CANCELED",
1227            Self::InvalidGroupCanceled => "INVALID_GROUP_CANCELED",
1228            Self::InputOutdatedCanceled => "INPUT_OUTDATED_CANCELED",
1229            Self::ExecuteFailed => "EXECUTE_FAILED",
1230            Self::JoinHandleFailed => "JOIN_HANDLE_FAILED",
1231            Self::TrackSstObjectIdFailed => "TRACK_SST_OBJECT_ID_FAILED",
1232            Self::NoAvailCpuResourceCanceled => "NO_AVAIL_CPU_RESOURCE_CANCELED",
1233            Self::HeartbeatProgressCanceled => "HEARTBEAT_PROGRESS_CANCELED",
1234            Self::RetentionTimeRejected => "RETENTION_TIME_REJECTED",
1235            Self::ServerlessSendFailCanceled => "SERVERLESS_SEND_FAIL_CANCELED",
1236            Self::ServerlessTableNotFoundCanceled => "SERVERLESS_TABLE_NOT_FOUND_CANCELED",
1237        };
1238        serializer.serialize_str(variant)
1239    }
1240}
1241impl<'de> serde::Deserialize<'de> for compact_task::TaskStatus {
1242    #[allow(deprecated)]
1243    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1244    where
1245        D: serde::Deserializer<'de>,
1246    {
1247        const FIELDS: &[&str] = &[
1248            "UNSPECIFIED",
1249            "PENDING",
1250            "SUCCESS",
1251            "HEARTBEAT_CANCELED",
1252            "NO_AVAIL_MEMORY_RESOURCE_CANCELED",
1253            "ASSIGN_FAIL_CANCELED",
1254            "SEND_FAIL_CANCELED",
1255            "MANUAL_CANCELED",
1256            "INVALID_GROUP_CANCELED",
1257            "INPUT_OUTDATED_CANCELED",
1258            "EXECUTE_FAILED",
1259            "JOIN_HANDLE_FAILED",
1260            "TRACK_SST_OBJECT_ID_FAILED",
1261            "NO_AVAIL_CPU_RESOURCE_CANCELED",
1262            "HEARTBEAT_PROGRESS_CANCELED",
1263            "RETENTION_TIME_REJECTED",
1264            "SERVERLESS_SEND_FAIL_CANCELED",
1265            "SERVERLESS_TABLE_NOT_FOUND_CANCELED",
1266        ];
1267
1268        struct GeneratedVisitor;
1269
1270        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1271            type Value = compact_task::TaskStatus;
1272
1273            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1274                write!(formatter, "expected one of: {:?}", &FIELDS)
1275            }
1276
1277            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1278            where
1279                E: serde::de::Error,
1280            {
1281                i32::try_from(v)
1282                    .ok()
1283                    .and_then(|x| x.try_into().ok())
1284                    .ok_or_else(|| {
1285                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1286                    })
1287            }
1288
1289            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1290            where
1291                E: serde::de::Error,
1292            {
1293                i32::try_from(v)
1294                    .ok()
1295                    .and_then(|x| x.try_into().ok())
1296                    .ok_or_else(|| {
1297                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1298                    })
1299            }
1300
1301            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1302            where
1303                E: serde::de::Error,
1304            {
1305                match value {
1306                    "UNSPECIFIED" => Ok(compact_task::TaskStatus::Unspecified),
1307                    "PENDING" => Ok(compact_task::TaskStatus::Pending),
1308                    "SUCCESS" => Ok(compact_task::TaskStatus::Success),
1309                    "HEARTBEAT_CANCELED" => Ok(compact_task::TaskStatus::HeartbeatCanceled),
1310                    "NO_AVAIL_MEMORY_RESOURCE_CANCELED" => Ok(compact_task::TaskStatus::NoAvailMemoryResourceCanceled),
1311                    "ASSIGN_FAIL_CANCELED" => Ok(compact_task::TaskStatus::AssignFailCanceled),
1312                    "SEND_FAIL_CANCELED" => Ok(compact_task::TaskStatus::SendFailCanceled),
1313                    "MANUAL_CANCELED" => Ok(compact_task::TaskStatus::ManualCanceled),
1314                    "INVALID_GROUP_CANCELED" => Ok(compact_task::TaskStatus::InvalidGroupCanceled),
1315                    "INPUT_OUTDATED_CANCELED" => Ok(compact_task::TaskStatus::InputOutdatedCanceled),
1316                    "EXECUTE_FAILED" => Ok(compact_task::TaskStatus::ExecuteFailed),
1317                    "JOIN_HANDLE_FAILED" => Ok(compact_task::TaskStatus::JoinHandleFailed),
1318                    "TRACK_SST_OBJECT_ID_FAILED" => Ok(compact_task::TaskStatus::TrackSstObjectIdFailed),
1319                    "NO_AVAIL_CPU_RESOURCE_CANCELED" => Ok(compact_task::TaskStatus::NoAvailCpuResourceCanceled),
1320                    "HEARTBEAT_PROGRESS_CANCELED" => Ok(compact_task::TaskStatus::HeartbeatProgressCanceled),
1321                    "RETENTION_TIME_REJECTED" => Ok(compact_task::TaskStatus::RetentionTimeRejected),
1322                    "SERVERLESS_SEND_FAIL_CANCELED" => Ok(compact_task::TaskStatus::ServerlessSendFailCanceled),
1323                    "SERVERLESS_TABLE_NOT_FOUND_CANCELED" => Ok(compact_task::TaskStatus::ServerlessTableNotFoundCanceled),
1324                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1325                }
1326            }
1327        }
1328        deserializer.deserialize_any(GeneratedVisitor)
1329    }
1330}
1331impl serde::Serialize for compact_task::TaskType {
1332    #[allow(deprecated)]
1333    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1334    where
1335        S: serde::Serializer,
1336    {
1337        let variant = match self {
1338            Self::TypeUnspecified => "TYPE_UNSPECIFIED",
1339            Self::Dynamic => "DYNAMIC",
1340            Self::SpaceReclaim => "SPACE_RECLAIM",
1341            Self::Manual => "MANUAL",
1342            Self::SharedBuffer => "SHARED_BUFFER",
1343            Self::Ttl => "TTL",
1344            Self::Tombstone => "TOMBSTONE",
1345            Self::Emergency => "EMERGENCY",
1346            Self::VnodeWatermark => "VNODE_WATERMARK",
1347        };
1348        serializer.serialize_str(variant)
1349    }
1350}
1351impl<'de> serde::Deserialize<'de> for compact_task::TaskType {
1352    #[allow(deprecated)]
1353    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1354    where
1355        D: serde::Deserializer<'de>,
1356    {
1357        const FIELDS: &[&str] = &[
1358            "TYPE_UNSPECIFIED",
1359            "DYNAMIC",
1360            "SPACE_RECLAIM",
1361            "MANUAL",
1362            "SHARED_BUFFER",
1363            "TTL",
1364            "TOMBSTONE",
1365            "EMERGENCY",
1366            "VNODE_WATERMARK",
1367        ];
1368
1369        struct GeneratedVisitor;
1370
1371        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1372            type Value = compact_task::TaskType;
1373
1374            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1375                write!(formatter, "expected one of: {:?}", &FIELDS)
1376            }
1377
1378            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1379            where
1380                E: serde::de::Error,
1381            {
1382                i32::try_from(v)
1383                    .ok()
1384                    .and_then(|x| x.try_into().ok())
1385                    .ok_or_else(|| {
1386                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1387                    })
1388            }
1389
1390            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1391            where
1392                E: serde::de::Error,
1393            {
1394                i32::try_from(v)
1395                    .ok()
1396                    .and_then(|x| x.try_into().ok())
1397                    .ok_or_else(|| {
1398                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1399                    })
1400            }
1401
1402            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1403            where
1404                E: serde::de::Error,
1405            {
1406                match value {
1407                    "TYPE_UNSPECIFIED" => Ok(compact_task::TaskType::TypeUnspecified),
1408                    "DYNAMIC" => Ok(compact_task::TaskType::Dynamic),
1409                    "SPACE_RECLAIM" => Ok(compact_task::TaskType::SpaceReclaim),
1410                    "MANUAL" => Ok(compact_task::TaskType::Manual),
1411                    "SHARED_BUFFER" => Ok(compact_task::TaskType::SharedBuffer),
1412                    "TTL" => Ok(compact_task::TaskType::Ttl),
1413                    "TOMBSTONE" => Ok(compact_task::TaskType::Tombstone),
1414                    "EMERGENCY" => Ok(compact_task::TaskType::Emergency),
1415                    "VNODE_WATERMARK" => Ok(compact_task::TaskType::VnodeWatermark),
1416                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1417                }
1418            }
1419        }
1420        deserializer.deserialize_any(GeneratedVisitor)
1421    }
1422}
1423impl serde::Serialize for CompactTaskAssignment {
1424    #[allow(deprecated)]
1425    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1426    where
1427        S: serde::Serializer,
1428    {
1429        use serde::ser::SerializeStruct;
1430        let mut len = 0;
1431        if self.compact_task.is_some() {
1432            len += 1;
1433        }
1434        if self.context_id != 0 {
1435            len += 1;
1436        }
1437        let mut struct_ser = serializer.serialize_struct("hummock.CompactTaskAssignment", len)?;
1438        if let Some(v) = self.compact_task.as_ref() {
1439            struct_ser.serialize_field("compactTask", v)?;
1440        }
1441        if self.context_id != 0 {
1442            struct_ser.serialize_field("contextId", &self.context_id)?;
1443        }
1444        struct_ser.end()
1445    }
1446}
1447impl<'de> serde::Deserialize<'de> for CompactTaskAssignment {
1448    #[allow(deprecated)]
1449    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1450    where
1451        D: serde::Deserializer<'de>,
1452    {
1453        const FIELDS: &[&str] = &[
1454            "compact_task",
1455            "compactTask",
1456            "context_id",
1457            "contextId",
1458        ];
1459
1460        #[allow(clippy::enum_variant_names)]
1461        enum GeneratedField {
1462            CompactTask,
1463            ContextId,
1464        }
1465        impl<'de> serde::Deserialize<'de> for GeneratedField {
1466            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1467            where
1468                D: serde::Deserializer<'de>,
1469            {
1470                struct GeneratedVisitor;
1471
1472                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1473                    type Value = GeneratedField;
1474
1475                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1476                        write!(formatter, "expected one of: {:?}", &FIELDS)
1477                    }
1478
1479                    #[allow(unused_variables)]
1480                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1481                    where
1482                        E: serde::de::Error,
1483                    {
1484                        match value {
1485                            "compactTask" | "compact_task" => Ok(GeneratedField::CompactTask),
1486                            "contextId" | "context_id" => Ok(GeneratedField::ContextId),
1487                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1488                        }
1489                    }
1490                }
1491                deserializer.deserialize_identifier(GeneratedVisitor)
1492            }
1493        }
1494        struct GeneratedVisitor;
1495        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1496            type Value = CompactTaskAssignment;
1497
1498            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1499                formatter.write_str("struct hummock.CompactTaskAssignment")
1500            }
1501
1502            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactTaskAssignment, V::Error>
1503                where
1504                    V: serde::de::MapAccess<'de>,
1505            {
1506                let mut compact_task__ = None;
1507                let mut context_id__ = None;
1508                while let Some(k) = map_.next_key()? {
1509                    match k {
1510                        GeneratedField::CompactTask => {
1511                            if compact_task__.is_some() {
1512                                return Err(serde::de::Error::duplicate_field("compactTask"));
1513                            }
1514                            compact_task__ = map_.next_value()?;
1515                        }
1516                        GeneratedField::ContextId => {
1517                            if context_id__.is_some() {
1518                                return Err(serde::de::Error::duplicate_field("contextId"));
1519                            }
1520                            context_id__ = 
1521                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1522                            ;
1523                        }
1524                    }
1525                }
1526                Ok(CompactTaskAssignment {
1527                    compact_task: compact_task__,
1528                    context_id: context_id__.unwrap_or_default(),
1529                })
1530            }
1531        }
1532        deserializer.deserialize_struct("hummock.CompactTaskAssignment", FIELDS, GeneratedVisitor)
1533    }
1534}
1535impl serde::Serialize for CompactTaskProgress {
1536    #[allow(deprecated)]
1537    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1538    where
1539        S: serde::Serializer,
1540    {
1541        use serde::ser::SerializeStruct;
1542        let mut len = 0;
1543        if self.task_id != 0 {
1544            len += 1;
1545        }
1546        if self.num_ssts_sealed != 0 {
1547            len += 1;
1548        }
1549        if self.num_ssts_uploaded != 0 {
1550            len += 1;
1551        }
1552        if self.num_progress_key != 0 {
1553            len += 1;
1554        }
1555        if self.num_pending_read_io != 0 {
1556            len += 1;
1557        }
1558        if self.num_pending_write_io != 0 {
1559            len += 1;
1560        }
1561        if self.compaction_group_id.is_some() {
1562            len += 1;
1563        }
1564        let mut struct_ser = serializer.serialize_struct("hummock.CompactTaskProgress", len)?;
1565        if self.task_id != 0 {
1566            #[allow(clippy::needless_borrow)]
1567            #[allow(clippy::needless_borrows_for_generic_args)]
1568            struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
1569        }
1570        if self.num_ssts_sealed != 0 {
1571            struct_ser.serialize_field("numSstsSealed", &self.num_ssts_sealed)?;
1572        }
1573        if self.num_ssts_uploaded != 0 {
1574            struct_ser.serialize_field("numSstsUploaded", &self.num_ssts_uploaded)?;
1575        }
1576        if self.num_progress_key != 0 {
1577            #[allow(clippy::needless_borrow)]
1578            #[allow(clippy::needless_borrows_for_generic_args)]
1579            struct_ser.serialize_field("numProgressKey", ToString::to_string(&self.num_progress_key).as_str())?;
1580        }
1581        if self.num_pending_read_io != 0 {
1582            #[allow(clippy::needless_borrow)]
1583            #[allow(clippy::needless_borrows_for_generic_args)]
1584            struct_ser.serialize_field("numPendingReadIo", ToString::to_string(&self.num_pending_read_io).as_str())?;
1585        }
1586        if self.num_pending_write_io != 0 {
1587            #[allow(clippy::needless_borrow)]
1588            #[allow(clippy::needless_borrows_for_generic_args)]
1589            struct_ser.serialize_field("numPendingWriteIo", ToString::to_string(&self.num_pending_write_io).as_str())?;
1590        }
1591        if let Some(v) = self.compaction_group_id.as_ref() {
1592            #[allow(clippy::needless_borrow)]
1593            #[allow(clippy::needless_borrows_for_generic_args)]
1594            struct_ser.serialize_field("compactionGroupId", ToString::to_string(&v).as_str())?;
1595        }
1596        struct_ser.end()
1597    }
1598}
1599impl<'de> serde::Deserialize<'de> for CompactTaskProgress {
1600    #[allow(deprecated)]
1601    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1602    where
1603        D: serde::Deserializer<'de>,
1604    {
1605        const FIELDS: &[&str] = &[
1606            "task_id",
1607            "taskId",
1608            "num_ssts_sealed",
1609            "numSstsSealed",
1610            "num_ssts_uploaded",
1611            "numSstsUploaded",
1612            "num_progress_key",
1613            "numProgressKey",
1614            "num_pending_read_io",
1615            "numPendingReadIo",
1616            "num_pending_write_io",
1617            "numPendingWriteIo",
1618            "compaction_group_id",
1619            "compactionGroupId",
1620        ];
1621
1622        #[allow(clippy::enum_variant_names)]
1623        enum GeneratedField {
1624            TaskId,
1625            NumSstsSealed,
1626            NumSstsUploaded,
1627            NumProgressKey,
1628            NumPendingReadIo,
1629            NumPendingWriteIo,
1630            CompactionGroupId,
1631        }
1632        impl<'de> serde::Deserialize<'de> for GeneratedField {
1633            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1634            where
1635                D: serde::Deserializer<'de>,
1636            {
1637                struct GeneratedVisitor;
1638
1639                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1640                    type Value = GeneratedField;
1641
1642                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1643                        write!(formatter, "expected one of: {:?}", &FIELDS)
1644                    }
1645
1646                    #[allow(unused_variables)]
1647                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1648                    where
1649                        E: serde::de::Error,
1650                    {
1651                        match value {
1652                            "taskId" | "task_id" => Ok(GeneratedField::TaskId),
1653                            "numSstsSealed" | "num_ssts_sealed" => Ok(GeneratedField::NumSstsSealed),
1654                            "numSstsUploaded" | "num_ssts_uploaded" => Ok(GeneratedField::NumSstsUploaded),
1655                            "numProgressKey" | "num_progress_key" => Ok(GeneratedField::NumProgressKey),
1656                            "numPendingReadIo" | "num_pending_read_io" => Ok(GeneratedField::NumPendingReadIo),
1657                            "numPendingWriteIo" | "num_pending_write_io" => Ok(GeneratedField::NumPendingWriteIo),
1658                            "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
1659                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1660                        }
1661                    }
1662                }
1663                deserializer.deserialize_identifier(GeneratedVisitor)
1664            }
1665        }
1666        struct GeneratedVisitor;
1667        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1668            type Value = CompactTaskProgress;
1669
1670            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1671                formatter.write_str("struct hummock.CompactTaskProgress")
1672            }
1673
1674            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactTaskProgress, V::Error>
1675                where
1676                    V: serde::de::MapAccess<'de>,
1677            {
1678                let mut task_id__ = None;
1679                let mut num_ssts_sealed__ = None;
1680                let mut num_ssts_uploaded__ = None;
1681                let mut num_progress_key__ = None;
1682                let mut num_pending_read_io__ = None;
1683                let mut num_pending_write_io__ = None;
1684                let mut compaction_group_id__ = None;
1685                while let Some(k) = map_.next_key()? {
1686                    match k {
1687                        GeneratedField::TaskId => {
1688                            if task_id__.is_some() {
1689                                return Err(serde::de::Error::duplicate_field("taskId"));
1690                            }
1691                            task_id__ = 
1692                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1693                            ;
1694                        }
1695                        GeneratedField::NumSstsSealed => {
1696                            if num_ssts_sealed__.is_some() {
1697                                return Err(serde::de::Error::duplicate_field("numSstsSealed"));
1698                            }
1699                            num_ssts_sealed__ = 
1700                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1701                            ;
1702                        }
1703                        GeneratedField::NumSstsUploaded => {
1704                            if num_ssts_uploaded__.is_some() {
1705                                return Err(serde::de::Error::duplicate_field("numSstsUploaded"));
1706                            }
1707                            num_ssts_uploaded__ = 
1708                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1709                            ;
1710                        }
1711                        GeneratedField::NumProgressKey => {
1712                            if num_progress_key__.is_some() {
1713                                return Err(serde::de::Error::duplicate_field("numProgressKey"));
1714                            }
1715                            num_progress_key__ = 
1716                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1717                            ;
1718                        }
1719                        GeneratedField::NumPendingReadIo => {
1720                            if num_pending_read_io__.is_some() {
1721                                return Err(serde::de::Error::duplicate_field("numPendingReadIo"));
1722                            }
1723                            num_pending_read_io__ = 
1724                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1725                            ;
1726                        }
1727                        GeneratedField::NumPendingWriteIo => {
1728                            if num_pending_write_io__.is_some() {
1729                                return Err(serde::de::Error::duplicate_field("numPendingWriteIo"));
1730                            }
1731                            num_pending_write_io__ = 
1732                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1733                            ;
1734                        }
1735                        GeneratedField::CompactionGroupId => {
1736                            if compaction_group_id__.is_some() {
1737                                return Err(serde::de::Error::duplicate_field("compactionGroupId"));
1738                            }
1739                            compaction_group_id__ = 
1740                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1741                            ;
1742                        }
1743                    }
1744                }
1745                Ok(CompactTaskProgress {
1746                    task_id: task_id__.unwrap_or_default(),
1747                    num_ssts_sealed: num_ssts_sealed__.unwrap_or_default(),
1748                    num_ssts_uploaded: num_ssts_uploaded__.unwrap_or_default(),
1749                    num_progress_key: num_progress_key__.unwrap_or_default(),
1750                    num_pending_read_io: num_pending_read_io__.unwrap_or_default(),
1751                    num_pending_write_io: num_pending_write_io__.unwrap_or_default(),
1752                    compaction_group_id: compaction_group_id__,
1753                })
1754            }
1755        }
1756        deserializer.deserialize_struct("hummock.CompactTaskProgress", FIELDS, GeneratedVisitor)
1757    }
1758}
1759impl serde::Serialize for CompactionConfig {
1760    #[allow(deprecated)]
1761    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1762    where
1763        S: serde::Serializer,
1764    {
1765        use serde::ser::SerializeStruct;
1766        let mut len = 0;
1767        if self.max_bytes_for_level_base != 0 {
1768            len += 1;
1769        }
1770        if self.max_level != 0 {
1771            len += 1;
1772        }
1773        if self.max_bytes_for_level_multiplier != 0 {
1774            len += 1;
1775        }
1776        if self.max_compaction_bytes != 0 {
1777            len += 1;
1778        }
1779        if self.sub_level_max_compaction_bytes != 0 {
1780            len += 1;
1781        }
1782        if self.level0_tier_compact_file_number != 0 {
1783            len += 1;
1784        }
1785        if self.compaction_mode != 0 {
1786            len += 1;
1787        }
1788        if !self.compression_algorithm.is_empty() {
1789            len += 1;
1790        }
1791        if self.target_file_size_base != 0 {
1792            len += 1;
1793        }
1794        if self.compaction_filter_mask != 0 {
1795            len += 1;
1796        }
1797        if self.max_sub_compaction != 0 {
1798            len += 1;
1799        }
1800        if self.max_space_reclaim_bytes != 0 {
1801            len += 1;
1802        }
1803        if self.split_by_state_table {
1804            len += 1;
1805        }
1806        if self.split_weight_by_vnode != 0 {
1807            len += 1;
1808        }
1809        if self.level0_stop_write_threshold_sub_level_number != 0 {
1810            len += 1;
1811        }
1812        if self.level0_max_compact_file_number != 0 {
1813            len += 1;
1814        }
1815        if self.level0_sub_level_compact_level_count != 0 {
1816            len += 1;
1817        }
1818        if self.level0_overlapping_sub_level_compact_level_count != 0 {
1819            len += 1;
1820        }
1821        if self.tombstone_reclaim_ratio != 0 {
1822            len += 1;
1823        }
1824        if self.enable_emergency_picker {
1825            len += 1;
1826        }
1827        if self.max_l0_compact_level_count.is_some() {
1828            len += 1;
1829        }
1830        if self.sst_allowed_trivial_move_min_size.is_some() {
1831            len += 1;
1832        }
1833        if self.disable_auto_group_scheduling.is_some() {
1834            len += 1;
1835        }
1836        if self.max_overlapping_level_size.is_some() {
1837            len += 1;
1838        }
1839        if self.emergency_level0_sst_file_count.is_some() {
1840            len += 1;
1841        }
1842        if self.emergency_level0_sub_level_partition.is_some() {
1843            len += 1;
1844        }
1845        if self.level0_stop_write_threshold_max_sst_count.is_some() {
1846            len += 1;
1847        }
1848        if self.level0_stop_write_threshold_max_size.is_some() {
1849            len += 1;
1850        }
1851        if self.sst_allowed_trivial_move_max_count.is_some() {
1852            len += 1;
1853        }
1854        if self.enable_optimize_l0_interval_selection.is_some() {
1855            len += 1;
1856        }
1857        let mut struct_ser = serializer.serialize_struct("hummock.CompactionConfig", len)?;
1858        if self.max_bytes_for_level_base != 0 {
1859            #[allow(clippy::needless_borrow)]
1860            #[allow(clippy::needless_borrows_for_generic_args)]
1861            struct_ser.serialize_field("maxBytesForLevelBase", ToString::to_string(&self.max_bytes_for_level_base).as_str())?;
1862        }
1863        if self.max_level != 0 {
1864            #[allow(clippy::needless_borrow)]
1865            #[allow(clippy::needless_borrows_for_generic_args)]
1866            struct_ser.serialize_field("maxLevel", ToString::to_string(&self.max_level).as_str())?;
1867        }
1868        if self.max_bytes_for_level_multiplier != 0 {
1869            #[allow(clippy::needless_borrow)]
1870            #[allow(clippy::needless_borrows_for_generic_args)]
1871            struct_ser.serialize_field("maxBytesForLevelMultiplier", ToString::to_string(&self.max_bytes_for_level_multiplier).as_str())?;
1872        }
1873        if self.max_compaction_bytes != 0 {
1874            #[allow(clippy::needless_borrow)]
1875            #[allow(clippy::needless_borrows_for_generic_args)]
1876            struct_ser.serialize_field("maxCompactionBytes", ToString::to_string(&self.max_compaction_bytes).as_str())?;
1877        }
1878        if self.sub_level_max_compaction_bytes != 0 {
1879            #[allow(clippy::needless_borrow)]
1880            #[allow(clippy::needless_borrows_for_generic_args)]
1881            struct_ser.serialize_field("subLevelMaxCompactionBytes", ToString::to_string(&self.sub_level_max_compaction_bytes).as_str())?;
1882        }
1883        if self.level0_tier_compact_file_number != 0 {
1884            #[allow(clippy::needless_borrow)]
1885            #[allow(clippy::needless_borrows_for_generic_args)]
1886            struct_ser.serialize_field("level0TierCompactFileNumber", ToString::to_string(&self.level0_tier_compact_file_number).as_str())?;
1887        }
1888        if self.compaction_mode != 0 {
1889            let v = compaction_config::CompactionMode::try_from(self.compaction_mode)
1890                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.compaction_mode)))?;
1891            struct_ser.serialize_field("compactionMode", &v)?;
1892        }
1893        if !self.compression_algorithm.is_empty() {
1894            struct_ser.serialize_field("compressionAlgorithm", &self.compression_algorithm)?;
1895        }
1896        if self.target_file_size_base != 0 {
1897            #[allow(clippy::needless_borrow)]
1898            #[allow(clippy::needless_borrows_for_generic_args)]
1899            struct_ser.serialize_field("targetFileSizeBase", ToString::to_string(&self.target_file_size_base).as_str())?;
1900        }
1901        if self.compaction_filter_mask != 0 {
1902            struct_ser.serialize_field("compactionFilterMask", &self.compaction_filter_mask)?;
1903        }
1904        if self.max_sub_compaction != 0 {
1905            struct_ser.serialize_field("maxSubCompaction", &self.max_sub_compaction)?;
1906        }
1907        if self.max_space_reclaim_bytes != 0 {
1908            #[allow(clippy::needless_borrow)]
1909            #[allow(clippy::needless_borrows_for_generic_args)]
1910            struct_ser.serialize_field("maxSpaceReclaimBytes", ToString::to_string(&self.max_space_reclaim_bytes).as_str())?;
1911        }
1912        if self.split_by_state_table {
1913            struct_ser.serialize_field("splitByStateTable", &self.split_by_state_table)?;
1914        }
1915        if self.split_weight_by_vnode != 0 {
1916            struct_ser.serialize_field("splitWeightByVnode", &self.split_weight_by_vnode)?;
1917        }
1918        if self.level0_stop_write_threshold_sub_level_number != 0 {
1919            #[allow(clippy::needless_borrow)]
1920            #[allow(clippy::needless_borrows_for_generic_args)]
1921            struct_ser.serialize_field("level0StopWriteThresholdSubLevelNumber", ToString::to_string(&self.level0_stop_write_threshold_sub_level_number).as_str())?;
1922        }
1923        if self.level0_max_compact_file_number != 0 {
1924            #[allow(clippy::needless_borrow)]
1925            #[allow(clippy::needless_borrows_for_generic_args)]
1926            struct_ser.serialize_field("level0MaxCompactFileNumber", ToString::to_string(&self.level0_max_compact_file_number).as_str())?;
1927        }
1928        if self.level0_sub_level_compact_level_count != 0 {
1929            struct_ser.serialize_field("level0SubLevelCompactLevelCount", &self.level0_sub_level_compact_level_count)?;
1930        }
1931        if self.level0_overlapping_sub_level_compact_level_count != 0 {
1932            struct_ser.serialize_field("level0OverlappingSubLevelCompactLevelCount", &self.level0_overlapping_sub_level_compact_level_count)?;
1933        }
1934        if self.tombstone_reclaim_ratio != 0 {
1935            struct_ser.serialize_field("tombstoneReclaimRatio", &self.tombstone_reclaim_ratio)?;
1936        }
1937        if self.enable_emergency_picker {
1938            struct_ser.serialize_field("enableEmergencyPicker", &self.enable_emergency_picker)?;
1939        }
1940        if let Some(v) = self.max_l0_compact_level_count.as_ref() {
1941            struct_ser.serialize_field("maxL0CompactLevelCount", v)?;
1942        }
1943        if let Some(v) = self.sst_allowed_trivial_move_min_size.as_ref() {
1944            #[allow(clippy::needless_borrow)]
1945            #[allow(clippy::needless_borrows_for_generic_args)]
1946            struct_ser.serialize_field("sstAllowedTrivialMoveMinSize", ToString::to_string(&v).as_str())?;
1947        }
1948        if let Some(v) = self.disable_auto_group_scheduling.as_ref() {
1949            struct_ser.serialize_field("disableAutoGroupScheduling", v)?;
1950        }
1951        if let Some(v) = self.max_overlapping_level_size.as_ref() {
1952            #[allow(clippy::needless_borrow)]
1953            #[allow(clippy::needless_borrows_for_generic_args)]
1954            struct_ser.serialize_field("maxOverlappingLevelSize", ToString::to_string(&v).as_str())?;
1955        }
1956        if let Some(v) = self.emergency_level0_sst_file_count.as_ref() {
1957            struct_ser.serialize_field("emergencyLevel0SstFileCount", v)?;
1958        }
1959        if let Some(v) = self.emergency_level0_sub_level_partition.as_ref() {
1960            struct_ser.serialize_field("emergencyLevel0SubLevelPartition", v)?;
1961        }
1962        if let Some(v) = self.level0_stop_write_threshold_max_sst_count.as_ref() {
1963            struct_ser.serialize_field("level0StopWriteThresholdMaxSstCount", v)?;
1964        }
1965        if let Some(v) = self.level0_stop_write_threshold_max_size.as_ref() {
1966            #[allow(clippy::needless_borrow)]
1967            #[allow(clippy::needless_borrows_for_generic_args)]
1968            struct_ser.serialize_field("level0StopWriteThresholdMaxSize", ToString::to_string(&v).as_str())?;
1969        }
1970        if let Some(v) = self.sst_allowed_trivial_move_max_count.as_ref() {
1971            struct_ser.serialize_field("sstAllowedTrivialMoveMaxCount", v)?;
1972        }
1973        if let Some(v) = self.enable_optimize_l0_interval_selection.as_ref() {
1974            struct_ser.serialize_field("enableOptimizeL0IntervalSelection", v)?;
1975        }
1976        struct_ser.end()
1977    }
1978}
1979impl<'de> serde::Deserialize<'de> for CompactionConfig {
1980    #[allow(deprecated)]
1981    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1982    where
1983        D: serde::Deserializer<'de>,
1984    {
1985        const FIELDS: &[&str] = &[
1986            "max_bytes_for_level_base",
1987            "maxBytesForLevelBase",
1988            "max_level",
1989            "maxLevel",
1990            "max_bytes_for_level_multiplier",
1991            "maxBytesForLevelMultiplier",
1992            "max_compaction_bytes",
1993            "maxCompactionBytes",
1994            "sub_level_max_compaction_bytes",
1995            "subLevelMaxCompactionBytes",
1996            "level0_tier_compact_file_number",
1997            "level0TierCompactFileNumber",
1998            "compaction_mode",
1999            "compactionMode",
2000            "compression_algorithm",
2001            "compressionAlgorithm",
2002            "target_file_size_base",
2003            "targetFileSizeBase",
2004            "compaction_filter_mask",
2005            "compactionFilterMask",
2006            "max_sub_compaction",
2007            "maxSubCompaction",
2008            "max_space_reclaim_bytes",
2009            "maxSpaceReclaimBytes",
2010            "split_by_state_table",
2011            "splitByStateTable",
2012            "split_weight_by_vnode",
2013            "splitWeightByVnode",
2014            "level0_stop_write_threshold_sub_level_number",
2015            "level0StopWriteThresholdSubLevelNumber",
2016            "level0_max_compact_file_number",
2017            "level0MaxCompactFileNumber",
2018            "level0_sub_level_compact_level_count",
2019            "level0SubLevelCompactLevelCount",
2020            "level0_overlapping_sub_level_compact_level_count",
2021            "level0OverlappingSubLevelCompactLevelCount",
2022            "tombstone_reclaim_ratio",
2023            "tombstoneReclaimRatio",
2024            "enable_emergency_picker",
2025            "enableEmergencyPicker",
2026            "max_l0_compact_level_count",
2027            "maxL0CompactLevelCount",
2028            "sst_allowed_trivial_move_min_size",
2029            "sstAllowedTrivialMoveMinSize",
2030            "disable_auto_group_scheduling",
2031            "disableAutoGroupScheduling",
2032            "max_overlapping_level_size",
2033            "maxOverlappingLevelSize",
2034            "emergency_level0_sst_file_count",
2035            "emergencyLevel0SstFileCount",
2036            "emergency_level0_sub_level_partition",
2037            "emergencyLevel0SubLevelPartition",
2038            "level0_stop_write_threshold_max_sst_count",
2039            "level0StopWriteThresholdMaxSstCount",
2040            "level0_stop_write_threshold_max_size",
2041            "level0StopWriteThresholdMaxSize",
2042            "sst_allowed_trivial_move_max_count",
2043            "sstAllowedTrivialMoveMaxCount",
2044            "enable_optimize_l0_interval_selection",
2045            "enableOptimizeL0IntervalSelection",
2046        ];
2047
2048        #[allow(clippy::enum_variant_names)]
2049        enum GeneratedField {
2050            MaxBytesForLevelBase,
2051            MaxLevel,
2052            MaxBytesForLevelMultiplier,
2053            MaxCompactionBytes,
2054            SubLevelMaxCompactionBytes,
2055            Level0TierCompactFileNumber,
2056            CompactionMode,
2057            CompressionAlgorithm,
2058            TargetFileSizeBase,
2059            CompactionFilterMask,
2060            MaxSubCompaction,
2061            MaxSpaceReclaimBytes,
2062            SplitByStateTable,
2063            SplitWeightByVnode,
2064            Level0StopWriteThresholdSubLevelNumber,
2065            Level0MaxCompactFileNumber,
2066            Level0SubLevelCompactLevelCount,
2067            Level0OverlappingSubLevelCompactLevelCount,
2068            TombstoneReclaimRatio,
2069            EnableEmergencyPicker,
2070            MaxL0CompactLevelCount,
2071            SstAllowedTrivialMoveMinSize,
2072            DisableAutoGroupScheduling,
2073            MaxOverlappingLevelSize,
2074            EmergencyLevel0SstFileCount,
2075            EmergencyLevel0SubLevelPartition,
2076            Level0StopWriteThresholdMaxSstCount,
2077            Level0StopWriteThresholdMaxSize,
2078            SstAllowedTrivialMoveMaxCount,
2079            EnableOptimizeL0IntervalSelection,
2080        }
2081        impl<'de> serde::Deserialize<'de> for GeneratedField {
2082            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2083            where
2084                D: serde::Deserializer<'de>,
2085            {
2086                struct GeneratedVisitor;
2087
2088                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2089                    type Value = GeneratedField;
2090
2091                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2092                        write!(formatter, "expected one of: {:?}", &FIELDS)
2093                    }
2094
2095                    #[allow(unused_variables)]
2096                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2097                    where
2098                        E: serde::de::Error,
2099                    {
2100                        match value {
2101                            "maxBytesForLevelBase" | "max_bytes_for_level_base" => Ok(GeneratedField::MaxBytesForLevelBase),
2102                            "maxLevel" | "max_level" => Ok(GeneratedField::MaxLevel),
2103                            "maxBytesForLevelMultiplier" | "max_bytes_for_level_multiplier" => Ok(GeneratedField::MaxBytesForLevelMultiplier),
2104                            "maxCompactionBytes" | "max_compaction_bytes" => Ok(GeneratedField::MaxCompactionBytes),
2105                            "subLevelMaxCompactionBytes" | "sub_level_max_compaction_bytes" => Ok(GeneratedField::SubLevelMaxCompactionBytes),
2106                            "level0TierCompactFileNumber" | "level0_tier_compact_file_number" => Ok(GeneratedField::Level0TierCompactFileNumber),
2107                            "compactionMode" | "compaction_mode" => Ok(GeneratedField::CompactionMode),
2108                            "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
2109                            "targetFileSizeBase" | "target_file_size_base" => Ok(GeneratedField::TargetFileSizeBase),
2110                            "compactionFilterMask" | "compaction_filter_mask" => Ok(GeneratedField::CompactionFilterMask),
2111                            "maxSubCompaction" | "max_sub_compaction" => Ok(GeneratedField::MaxSubCompaction),
2112                            "maxSpaceReclaimBytes" | "max_space_reclaim_bytes" => Ok(GeneratedField::MaxSpaceReclaimBytes),
2113                            "splitByStateTable" | "split_by_state_table" => Ok(GeneratedField::SplitByStateTable),
2114                            "splitWeightByVnode" | "split_weight_by_vnode" => Ok(GeneratedField::SplitWeightByVnode),
2115                            "level0StopWriteThresholdSubLevelNumber" | "level0_stop_write_threshold_sub_level_number" => Ok(GeneratedField::Level0StopWriteThresholdSubLevelNumber),
2116                            "level0MaxCompactFileNumber" | "level0_max_compact_file_number" => Ok(GeneratedField::Level0MaxCompactFileNumber),
2117                            "level0SubLevelCompactLevelCount" | "level0_sub_level_compact_level_count" => Ok(GeneratedField::Level0SubLevelCompactLevelCount),
2118                            "level0OverlappingSubLevelCompactLevelCount" | "level0_overlapping_sub_level_compact_level_count" => Ok(GeneratedField::Level0OverlappingSubLevelCompactLevelCount),
2119                            "tombstoneReclaimRatio" | "tombstone_reclaim_ratio" => Ok(GeneratedField::TombstoneReclaimRatio),
2120                            "enableEmergencyPicker" | "enable_emergency_picker" => Ok(GeneratedField::EnableEmergencyPicker),
2121                            "maxL0CompactLevelCount" | "max_l0_compact_level_count" => Ok(GeneratedField::MaxL0CompactLevelCount),
2122                            "sstAllowedTrivialMoveMinSize" | "sst_allowed_trivial_move_min_size" => Ok(GeneratedField::SstAllowedTrivialMoveMinSize),
2123                            "disableAutoGroupScheduling" | "disable_auto_group_scheduling" => Ok(GeneratedField::DisableAutoGroupScheduling),
2124                            "maxOverlappingLevelSize" | "max_overlapping_level_size" => Ok(GeneratedField::MaxOverlappingLevelSize),
2125                            "emergencyLevel0SstFileCount" | "emergency_level0_sst_file_count" => Ok(GeneratedField::EmergencyLevel0SstFileCount),
2126                            "emergencyLevel0SubLevelPartition" | "emergency_level0_sub_level_partition" => Ok(GeneratedField::EmergencyLevel0SubLevelPartition),
2127                            "level0StopWriteThresholdMaxSstCount" | "level0_stop_write_threshold_max_sst_count" => Ok(GeneratedField::Level0StopWriteThresholdMaxSstCount),
2128                            "level0StopWriteThresholdMaxSize" | "level0_stop_write_threshold_max_size" => Ok(GeneratedField::Level0StopWriteThresholdMaxSize),
2129                            "sstAllowedTrivialMoveMaxCount" | "sst_allowed_trivial_move_max_count" => Ok(GeneratedField::SstAllowedTrivialMoveMaxCount),
2130                            "enableOptimizeL0IntervalSelection" | "enable_optimize_l0_interval_selection" => Ok(GeneratedField::EnableOptimizeL0IntervalSelection),
2131                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2132                        }
2133                    }
2134                }
2135                deserializer.deserialize_identifier(GeneratedVisitor)
2136            }
2137        }
2138        struct GeneratedVisitor;
2139        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2140            type Value = CompactionConfig;
2141
2142            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2143                formatter.write_str("struct hummock.CompactionConfig")
2144            }
2145
2146            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactionConfig, V::Error>
2147                where
2148                    V: serde::de::MapAccess<'de>,
2149            {
2150                let mut max_bytes_for_level_base__ = None;
2151                let mut max_level__ = None;
2152                let mut max_bytes_for_level_multiplier__ = None;
2153                let mut max_compaction_bytes__ = None;
2154                let mut sub_level_max_compaction_bytes__ = None;
2155                let mut level0_tier_compact_file_number__ = None;
2156                let mut compaction_mode__ = None;
2157                let mut compression_algorithm__ = None;
2158                let mut target_file_size_base__ = None;
2159                let mut compaction_filter_mask__ = None;
2160                let mut max_sub_compaction__ = None;
2161                let mut max_space_reclaim_bytes__ = None;
2162                let mut split_by_state_table__ = None;
2163                let mut split_weight_by_vnode__ = None;
2164                let mut level0_stop_write_threshold_sub_level_number__ = None;
2165                let mut level0_max_compact_file_number__ = None;
2166                let mut level0_sub_level_compact_level_count__ = None;
2167                let mut level0_overlapping_sub_level_compact_level_count__ = None;
2168                let mut tombstone_reclaim_ratio__ = None;
2169                let mut enable_emergency_picker__ = None;
2170                let mut max_l0_compact_level_count__ = None;
2171                let mut sst_allowed_trivial_move_min_size__ = None;
2172                let mut disable_auto_group_scheduling__ = None;
2173                let mut max_overlapping_level_size__ = None;
2174                let mut emergency_level0_sst_file_count__ = None;
2175                let mut emergency_level0_sub_level_partition__ = None;
2176                let mut level0_stop_write_threshold_max_sst_count__ = None;
2177                let mut level0_stop_write_threshold_max_size__ = None;
2178                let mut sst_allowed_trivial_move_max_count__ = None;
2179                let mut enable_optimize_l0_interval_selection__ = None;
2180                while let Some(k) = map_.next_key()? {
2181                    match k {
2182                        GeneratedField::MaxBytesForLevelBase => {
2183                            if max_bytes_for_level_base__.is_some() {
2184                                return Err(serde::de::Error::duplicate_field("maxBytesForLevelBase"));
2185                            }
2186                            max_bytes_for_level_base__ = 
2187                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2188                            ;
2189                        }
2190                        GeneratedField::MaxLevel => {
2191                            if max_level__.is_some() {
2192                                return Err(serde::de::Error::duplicate_field("maxLevel"));
2193                            }
2194                            max_level__ = 
2195                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2196                            ;
2197                        }
2198                        GeneratedField::MaxBytesForLevelMultiplier => {
2199                            if max_bytes_for_level_multiplier__.is_some() {
2200                                return Err(serde::de::Error::duplicate_field("maxBytesForLevelMultiplier"));
2201                            }
2202                            max_bytes_for_level_multiplier__ = 
2203                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2204                            ;
2205                        }
2206                        GeneratedField::MaxCompactionBytes => {
2207                            if max_compaction_bytes__.is_some() {
2208                                return Err(serde::de::Error::duplicate_field("maxCompactionBytes"));
2209                            }
2210                            max_compaction_bytes__ = 
2211                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2212                            ;
2213                        }
2214                        GeneratedField::SubLevelMaxCompactionBytes => {
2215                            if sub_level_max_compaction_bytes__.is_some() {
2216                                return Err(serde::de::Error::duplicate_field("subLevelMaxCompactionBytes"));
2217                            }
2218                            sub_level_max_compaction_bytes__ = 
2219                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2220                            ;
2221                        }
2222                        GeneratedField::Level0TierCompactFileNumber => {
2223                            if level0_tier_compact_file_number__.is_some() {
2224                                return Err(serde::de::Error::duplicate_field("level0TierCompactFileNumber"));
2225                            }
2226                            level0_tier_compact_file_number__ = 
2227                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2228                            ;
2229                        }
2230                        GeneratedField::CompactionMode => {
2231                            if compaction_mode__.is_some() {
2232                                return Err(serde::de::Error::duplicate_field("compactionMode"));
2233                            }
2234                            compaction_mode__ = Some(map_.next_value::<compaction_config::CompactionMode>()? as i32);
2235                        }
2236                        GeneratedField::CompressionAlgorithm => {
2237                            if compression_algorithm__.is_some() {
2238                                return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
2239                            }
2240                            compression_algorithm__ = Some(map_.next_value()?);
2241                        }
2242                        GeneratedField::TargetFileSizeBase => {
2243                            if target_file_size_base__.is_some() {
2244                                return Err(serde::de::Error::duplicate_field("targetFileSizeBase"));
2245                            }
2246                            target_file_size_base__ = 
2247                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2248                            ;
2249                        }
2250                        GeneratedField::CompactionFilterMask => {
2251                            if compaction_filter_mask__.is_some() {
2252                                return Err(serde::de::Error::duplicate_field("compactionFilterMask"));
2253                            }
2254                            compaction_filter_mask__ = 
2255                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2256                            ;
2257                        }
2258                        GeneratedField::MaxSubCompaction => {
2259                            if max_sub_compaction__.is_some() {
2260                                return Err(serde::de::Error::duplicate_field("maxSubCompaction"));
2261                            }
2262                            max_sub_compaction__ = 
2263                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2264                            ;
2265                        }
2266                        GeneratedField::MaxSpaceReclaimBytes => {
2267                            if max_space_reclaim_bytes__.is_some() {
2268                                return Err(serde::de::Error::duplicate_field("maxSpaceReclaimBytes"));
2269                            }
2270                            max_space_reclaim_bytes__ = 
2271                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2272                            ;
2273                        }
2274                        GeneratedField::SplitByStateTable => {
2275                            if split_by_state_table__.is_some() {
2276                                return Err(serde::de::Error::duplicate_field("splitByStateTable"));
2277                            }
2278                            split_by_state_table__ = Some(map_.next_value()?);
2279                        }
2280                        GeneratedField::SplitWeightByVnode => {
2281                            if split_weight_by_vnode__.is_some() {
2282                                return Err(serde::de::Error::duplicate_field("splitWeightByVnode"));
2283                            }
2284                            split_weight_by_vnode__ = 
2285                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2286                            ;
2287                        }
2288                        GeneratedField::Level0StopWriteThresholdSubLevelNumber => {
2289                            if level0_stop_write_threshold_sub_level_number__.is_some() {
2290                                return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdSubLevelNumber"));
2291                            }
2292                            level0_stop_write_threshold_sub_level_number__ = 
2293                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2294                            ;
2295                        }
2296                        GeneratedField::Level0MaxCompactFileNumber => {
2297                            if level0_max_compact_file_number__.is_some() {
2298                                return Err(serde::de::Error::duplicate_field("level0MaxCompactFileNumber"));
2299                            }
2300                            level0_max_compact_file_number__ = 
2301                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2302                            ;
2303                        }
2304                        GeneratedField::Level0SubLevelCompactLevelCount => {
2305                            if level0_sub_level_compact_level_count__.is_some() {
2306                                return Err(serde::de::Error::duplicate_field("level0SubLevelCompactLevelCount"));
2307                            }
2308                            level0_sub_level_compact_level_count__ = 
2309                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2310                            ;
2311                        }
2312                        GeneratedField::Level0OverlappingSubLevelCompactLevelCount => {
2313                            if level0_overlapping_sub_level_compact_level_count__.is_some() {
2314                                return Err(serde::de::Error::duplicate_field("level0OverlappingSubLevelCompactLevelCount"));
2315                            }
2316                            level0_overlapping_sub_level_compact_level_count__ = 
2317                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2318                            ;
2319                        }
2320                        GeneratedField::TombstoneReclaimRatio => {
2321                            if tombstone_reclaim_ratio__.is_some() {
2322                                return Err(serde::de::Error::duplicate_field("tombstoneReclaimRatio"));
2323                            }
2324                            tombstone_reclaim_ratio__ = 
2325                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2326                            ;
2327                        }
2328                        GeneratedField::EnableEmergencyPicker => {
2329                            if enable_emergency_picker__.is_some() {
2330                                return Err(serde::de::Error::duplicate_field("enableEmergencyPicker"));
2331                            }
2332                            enable_emergency_picker__ = Some(map_.next_value()?);
2333                        }
2334                        GeneratedField::MaxL0CompactLevelCount => {
2335                            if max_l0_compact_level_count__.is_some() {
2336                                return Err(serde::de::Error::duplicate_field("maxL0CompactLevelCount"));
2337                            }
2338                            max_l0_compact_level_count__ = 
2339                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2340                            ;
2341                        }
2342                        GeneratedField::SstAllowedTrivialMoveMinSize => {
2343                            if sst_allowed_trivial_move_min_size__.is_some() {
2344                                return Err(serde::de::Error::duplicate_field("sstAllowedTrivialMoveMinSize"));
2345                            }
2346                            sst_allowed_trivial_move_min_size__ = 
2347                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2348                            ;
2349                        }
2350                        GeneratedField::DisableAutoGroupScheduling => {
2351                            if disable_auto_group_scheduling__.is_some() {
2352                                return Err(serde::de::Error::duplicate_field("disableAutoGroupScheduling"));
2353                            }
2354                            disable_auto_group_scheduling__ = map_.next_value()?;
2355                        }
2356                        GeneratedField::MaxOverlappingLevelSize => {
2357                            if max_overlapping_level_size__.is_some() {
2358                                return Err(serde::de::Error::duplicate_field("maxOverlappingLevelSize"));
2359                            }
2360                            max_overlapping_level_size__ = 
2361                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2362                            ;
2363                        }
2364                        GeneratedField::EmergencyLevel0SstFileCount => {
2365                            if emergency_level0_sst_file_count__.is_some() {
2366                                return Err(serde::de::Error::duplicate_field("emergencyLevel0SstFileCount"));
2367                            }
2368                            emergency_level0_sst_file_count__ = 
2369                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2370                            ;
2371                        }
2372                        GeneratedField::EmergencyLevel0SubLevelPartition => {
2373                            if emergency_level0_sub_level_partition__.is_some() {
2374                                return Err(serde::de::Error::duplicate_field("emergencyLevel0SubLevelPartition"));
2375                            }
2376                            emergency_level0_sub_level_partition__ = 
2377                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2378                            ;
2379                        }
2380                        GeneratedField::Level0StopWriteThresholdMaxSstCount => {
2381                            if level0_stop_write_threshold_max_sst_count__.is_some() {
2382                                return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdMaxSstCount"));
2383                            }
2384                            level0_stop_write_threshold_max_sst_count__ = 
2385                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2386                            ;
2387                        }
2388                        GeneratedField::Level0StopWriteThresholdMaxSize => {
2389                            if level0_stop_write_threshold_max_size__.is_some() {
2390                                return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdMaxSize"));
2391                            }
2392                            level0_stop_write_threshold_max_size__ = 
2393                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2394                            ;
2395                        }
2396                        GeneratedField::SstAllowedTrivialMoveMaxCount => {
2397                            if sst_allowed_trivial_move_max_count__.is_some() {
2398                                return Err(serde::de::Error::duplicate_field("sstAllowedTrivialMoveMaxCount"));
2399                            }
2400                            sst_allowed_trivial_move_max_count__ = 
2401                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2402                            ;
2403                        }
2404                        GeneratedField::EnableOptimizeL0IntervalSelection => {
2405                            if enable_optimize_l0_interval_selection__.is_some() {
2406                                return Err(serde::de::Error::duplicate_field("enableOptimizeL0IntervalSelection"));
2407                            }
2408                            enable_optimize_l0_interval_selection__ = map_.next_value()?;
2409                        }
2410                    }
2411                }
2412                Ok(CompactionConfig {
2413                    max_bytes_for_level_base: max_bytes_for_level_base__.unwrap_or_default(),
2414                    max_level: max_level__.unwrap_or_default(),
2415                    max_bytes_for_level_multiplier: max_bytes_for_level_multiplier__.unwrap_or_default(),
2416                    max_compaction_bytes: max_compaction_bytes__.unwrap_or_default(),
2417                    sub_level_max_compaction_bytes: sub_level_max_compaction_bytes__.unwrap_or_default(),
2418                    level0_tier_compact_file_number: level0_tier_compact_file_number__.unwrap_or_default(),
2419                    compaction_mode: compaction_mode__.unwrap_or_default(),
2420                    compression_algorithm: compression_algorithm__.unwrap_or_default(),
2421                    target_file_size_base: target_file_size_base__.unwrap_or_default(),
2422                    compaction_filter_mask: compaction_filter_mask__.unwrap_or_default(),
2423                    max_sub_compaction: max_sub_compaction__.unwrap_or_default(),
2424                    max_space_reclaim_bytes: max_space_reclaim_bytes__.unwrap_or_default(),
2425                    split_by_state_table: split_by_state_table__.unwrap_or_default(),
2426                    split_weight_by_vnode: split_weight_by_vnode__.unwrap_or_default(),
2427                    level0_stop_write_threshold_sub_level_number: level0_stop_write_threshold_sub_level_number__.unwrap_or_default(),
2428                    level0_max_compact_file_number: level0_max_compact_file_number__.unwrap_or_default(),
2429                    level0_sub_level_compact_level_count: level0_sub_level_compact_level_count__.unwrap_or_default(),
2430                    level0_overlapping_sub_level_compact_level_count: level0_overlapping_sub_level_compact_level_count__.unwrap_or_default(),
2431                    tombstone_reclaim_ratio: tombstone_reclaim_ratio__.unwrap_or_default(),
2432                    enable_emergency_picker: enable_emergency_picker__.unwrap_or_default(),
2433                    max_l0_compact_level_count: max_l0_compact_level_count__,
2434                    sst_allowed_trivial_move_min_size: sst_allowed_trivial_move_min_size__,
2435                    disable_auto_group_scheduling: disable_auto_group_scheduling__,
2436                    max_overlapping_level_size: max_overlapping_level_size__,
2437                    emergency_level0_sst_file_count: emergency_level0_sst_file_count__,
2438                    emergency_level0_sub_level_partition: emergency_level0_sub_level_partition__,
2439                    level0_stop_write_threshold_max_sst_count: level0_stop_write_threshold_max_sst_count__,
2440                    level0_stop_write_threshold_max_size: level0_stop_write_threshold_max_size__,
2441                    sst_allowed_trivial_move_max_count: sst_allowed_trivial_move_max_count__,
2442                    enable_optimize_l0_interval_selection: enable_optimize_l0_interval_selection__,
2443                })
2444            }
2445        }
2446        deserializer.deserialize_struct("hummock.CompactionConfig", FIELDS, GeneratedVisitor)
2447    }
2448}
2449impl serde::Serialize for compaction_config::CompactionMode {
2450    #[allow(deprecated)]
2451    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2452    where
2453        S: serde::Serializer,
2454    {
2455        let variant = match self {
2456            Self::Unspecified => "UNSPECIFIED",
2457            Self::Range => "RANGE",
2458        };
2459        serializer.serialize_str(variant)
2460    }
2461}
2462impl<'de> serde::Deserialize<'de> for compaction_config::CompactionMode {
2463    #[allow(deprecated)]
2464    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2465    where
2466        D: serde::Deserializer<'de>,
2467    {
2468        const FIELDS: &[&str] = &[
2469            "UNSPECIFIED",
2470            "RANGE",
2471        ];
2472
2473        struct GeneratedVisitor;
2474
2475        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2476            type Value = compaction_config::CompactionMode;
2477
2478            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2479                write!(formatter, "expected one of: {:?}", &FIELDS)
2480            }
2481
2482            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2483            where
2484                E: serde::de::Error,
2485            {
2486                i32::try_from(v)
2487                    .ok()
2488                    .and_then(|x| x.try_into().ok())
2489                    .ok_or_else(|| {
2490                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2491                    })
2492            }
2493
2494            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2495            where
2496                E: serde::de::Error,
2497            {
2498                i32::try_from(v)
2499                    .ok()
2500                    .and_then(|x| x.try_into().ok())
2501                    .ok_or_else(|| {
2502                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2503                    })
2504            }
2505
2506            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2507            where
2508                E: serde::de::Error,
2509            {
2510                match value {
2511                    "UNSPECIFIED" => Ok(compaction_config::CompactionMode::Unspecified),
2512                    "RANGE" => Ok(compaction_config::CompactionMode::Range),
2513                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2514                }
2515            }
2516        }
2517        deserializer.deserialize_any(GeneratedVisitor)
2518    }
2519}
2520impl serde::Serialize for CompactionGroup {
2521    #[allow(deprecated)]
2522    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2523    where
2524        S: serde::Serializer,
2525    {
2526        use serde::ser::SerializeStruct;
2527        let mut len = 0;
2528        if self.id != 0 {
2529            len += 1;
2530        }
2531        if self.compaction_config.is_some() {
2532            len += 1;
2533        }
2534        let mut struct_ser = serializer.serialize_struct("hummock.CompactionGroup", len)?;
2535        if self.id != 0 {
2536            #[allow(clippy::needless_borrow)]
2537            #[allow(clippy::needless_borrows_for_generic_args)]
2538            struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
2539        }
2540        if let Some(v) = self.compaction_config.as_ref() {
2541            struct_ser.serialize_field("compactionConfig", v)?;
2542        }
2543        struct_ser.end()
2544    }
2545}
2546impl<'de> serde::Deserialize<'de> for CompactionGroup {
2547    #[allow(deprecated)]
2548    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2549    where
2550        D: serde::Deserializer<'de>,
2551    {
2552        const FIELDS: &[&str] = &[
2553            "id",
2554            "compaction_config",
2555            "compactionConfig",
2556        ];
2557
2558        #[allow(clippy::enum_variant_names)]
2559        enum GeneratedField {
2560            Id,
2561            CompactionConfig,
2562        }
2563        impl<'de> serde::Deserialize<'de> for GeneratedField {
2564            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2565            where
2566                D: serde::Deserializer<'de>,
2567            {
2568                struct GeneratedVisitor;
2569
2570                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2571                    type Value = GeneratedField;
2572
2573                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2574                        write!(formatter, "expected one of: {:?}", &FIELDS)
2575                    }
2576
2577                    #[allow(unused_variables)]
2578                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2579                    where
2580                        E: serde::de::Error,
2581                    {
2582                        match value {
2583                            "id" => Ok(GeneratedField::Id),
2584                            "compactionConfig" | "compaction_config" => Ok(GeneratedField::CompactionConfig),
2585                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2586                        }
2587                    }
2588                }
2589                deserializer.deserialize_identifier(GeneratedVisitor)
2590            }
2591        }
2592        struct GeneratedVisitor;
2593        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2594            type Value = CompactionGroup;
2595
2596            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2597                formatter.write_str("struct hummock.CompactionGroup")
2598            }
2599
2600            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactionGroup, V::Error>
2601                where
2602                    V: serde::de::MapAccess<'de>,
2603            {
2604                let mut id__ = None;
2605                let mut compaction_config__ = None;
2606                while let Some(k) = map_.next_key()? {
2607                    match k {
2608                        GeneratedField::Id => {
2609                            if id__.is_some() {
2610                                return Err(serde::de::Error::duplicate_field("id"));
2611                            }
2612                            id__ = 
2613                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2614                            ;
2615                        }
2616                        GeneratedField::CompactionConfig => {
2617                            if compaction_config__.is_some() {
2618                                return Err(serde::de::Error::duplicate_field("compactionConfig"));
2619                            }
2620                            compaction_config__ = map_.next_value()?;
2621                        }
2622                    }
2623                }
2624                Ok(CompactionGroup {
2625                    id: id__.unwrap_or_default(),
2626                    compaction_config: compaction_config__,
2627                })
2628            }
2629        }
2630        deserializer.deserialize_struct("hummock.CompactionGroup", FIELDS, GeneratedVisitor)
2631    }
2632}
2633impl serde::Serialize for CompactionGroupInfo {
2634    #[allow(deprecated)]
2635    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2636    where
2637        S: serde::Serializer,
2638    {
2639        use serde::ser::SerializeStruct;
2640        let mut len = 0;
2641        if self.id != 0 {
2642            len += 1;
2643        }
2644        if self.parent_id != 0 {
2645            len += 1;
2646        }
2647        if !self.member_table_ids.is_empty() {
2648            len += 1;
2649        }
2650        if self.compaction_config.is_some() {
2651            len += 1;
2652        }
2653        let mut struct_ser = serializer.serialize_struct("hummock.CompactionGroupInfo", len)?;
2654        if self.id != 0 {
2655            #[allow(clippy::needless_borrow)]
2656            #[allow(clippy::needless_borrows_for_generic_args)]
2657            struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
2658        }
2659        if self.parent_id != 0 {
2660            #[allow(clippy::needless_borrow)]
2661            #[allow(clippy::needless_borrows_for_generic_args)]
2662            struct_ser.serialize_field("parentId", ToString::to_string(&self.parent_id).as_str())?;
2663        }
2664        if !self.member_table_ids.is_empty() {
2665            struct_ser.serialize_field("memberTableIds", &self.member_table_ids)?;
2666        }
2667        if let Some(v) = self.compaction_config.as_ref() {
2668            struct_ser.serialize_field("compactionConfig", v)?;
2669        }
2670        struct_ser.end()
2671    }
2672}
2673impl<'de> serde::Deserialize<'de> for CompactionGroupInfo {
2674    #[allow(deprecated)]
2675    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2676    where
2677        D: serde::Deserializer<'de>,
2678    {
2679        const FIELDS: &[&str] = &[
2680            "id",
2681            "parent_id",
2682            "parentId",
2683            "member_table_ids",
2684            "memberTableIds",
2685            "compaction_config",
2686            "compactionConfig",
2687        ];
2688
2689        #[allow(clippy::enum_variant_names)]
2690        enum GeneratedField {
2691            Id,
2692            ParentId,
2693            MemberTableIds,
2694            CompactionConfig,
2695        }
2696        impl<'de> serde::Deserialize<'de> for GeneratedField {
2697            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2698            where
2699                D: serde::Deserializer<'de>,
2700            {
2701                struct GeneratedVisitor;
2702
2703                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2704                    type Value = GeneratedField;
2705
2706                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2707                        write!(formatter, "expected one of: {:?}", &FIELDS)
2708                    }
2709
2710                    #[allow(unused_variables)]
2711                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2712                    where
2713                        E: serde::de::Error,
2714                    {
2715                        match value {
2716                            "id" => Ok(GeneratedField::Id),
2717                            "parentId" | "parent_id" => Ok(GeneratedField::ParentId),
2718                            "memberTableIds" | "member_table_ids" => Ok(GeneratedField::MemberTableIds),
2719                            "compactionConfig" | "compaction_config" => Ok(GeneratedField::CompactionConfig),
2720                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2721                        }
2722                    }
2723                }
2724                deserializer.deserialize_identifier(GeneratedVisitor)
2725            }
2726        }
2727        struct GeneratedVisitor;
2728        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2729            type Value = CompactionGroupInfo;
2730
2731            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2732                formatter.write_str("struct hummock.CompactionGroupInfo")
2733            }
2734
2735            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CompactionGroupInfo, V::Error>
2736                where
2737                    V: serde::de::MapAccess<'de>,
2738            {
2739                let mut id__ = None;
2740                let mut parent_id__ = None;
2741                let mut member_table_ids__ = None;
2742                let mut compaction_config__ = None;
2743                while let Some(k) = map_.next_key()? {
2744                    match k {
2745                        GeneratedField::Id => {
2746                            if id__.is_some() {
2747                                return Err(serde::de::Error::duplicate_field("id"));
2748                            }
2749                            id__ = 
2750                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2751                            ;
2752                        }
2753                        GeneratedField::ParentId => {
2754                            if parent_id__.is_some() {
2755                                return Err(serde::de::Error::duplicate_field("parentId"));
2756                            }
2757                            parent_id__ = 
2758                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2759                            ;
2760                        }
2761                        GeneratedField::MemberTableIds => {
2762                            if member_table_ids__.is_some() {
2763                                return Err(serde::de::Error::duplicate_field("memberTableIds"));
2764                            }
2765                            member_table_ids__ = 
2766                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2767                                    .into_iter().map(|x| x.0).collect())
2768                            ;
2769                        }
2770                        GeneratedField::CompactionConfig => {
2771                            if compaction_config__.is_some() {
2772                                return Err(serde::de::Error::duplicate_field("compactionConfig"));
2773                            }
2774                            compaction_config__ = map_.next_value()?;
2775                        }
2776                    }
2777                }
2778                Ok(CompactionGroupInfo {
2779                    id: id__.unwrap_or_default(),
2780                    parent_id: parent_id__.unwrap_or_default(),
2781                    member_table_ids: member_table_ids__.unwrap_or_default(),
2782                    compaction_config: compaction_config__,
2783                })
2784            }
2785        }
2786        deserializer.deserialize_struct("hummock.CompactionGroupInfo", FIELDS, GeneratedVisitor)
2787    }
2788}
2789impl serde::Serialize for CompatibilityVersion {
2790    #[allow(deprecated)]
2791    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2792    where
2793        S: serde::Serializer,
2794    {
2795        let variant = match self {
2796            Self::VersionUnspecified => "VERSION_UNSPECIFIED",
2797            Self::NoTrivialSplit => "NO_TRIVIAL_SPLIT",
2798            Self::NoMemberTableIds => "NO_MEMBER_TABLE_IDS",
2799            Self::SplitGroupByTableId => "SPLIT_GROUP_BY_TABLE_ID",
2800        };
2801        serializer.serialize_str(variant)
2802    }
2803}
2804impl<'de> serde::Deserialize<'de> for CompatibilityVersion {
2805    #[allow(deprecated)]
2806    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2807    where
2808        D: serde::Deserializer<'de>,
2809    {
2810        const FIELDS: &[&str] = &[
2811            "VERSION_UNSPECIFIED",
2812            "NO_TRIVIAL_SPLIT",
2813            "NO_MEMBER_TABLE_IDS",
2814            "SPLIT_GROUP_BY_TABLE_ID",
2815        ];
2816
2817        struct GeneratedVisitor;
2818
2819        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2820            type Value = CompatibilityVersion;
2821
2822            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2823                write!(formatter, "expected one of: {:?}", &FIELDS)
2824            }
2825
2826            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2827            where
2828                E: serde::de::Error,
2829            {
2830                i32::try_from(v)
2831                    .ok()
2832                    .and_then(|x| x.try_into().ok())
2833                    .ok_or_else(|| {
2834                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2835                    })
2836            }
2837
2838            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2839            where
2840                E: serde::de::Error,
2841            {
2842                i32::try_from(v)
2843                    .ok()
2844                    .and_then(|x| x.try_into().ok())
2845                    .ok_or_else(|| {
2846                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2847                    })
2848            }
2849
2850            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2851            where
2852                E: serde::de::Error,
2853            {
2854                match value {
2855                    "VERSION_UNSPECIFIED" => Ok(CompatibilityVersion::VersionUnspecified),
2856                    "NO_TRIVIAL_SPLIT" => Ok(CompatibilityVersion::NoTrivialSplit),
2857                    "NO_MEMBER_TABLE_IDS" => Ok(CompatibilityVersion::NoMemberTableIds),
2858                    "SPLIT_GROUP_BY_TABLE_ID" => Ok(CompatibilityVersion::SplitGroupByTableId),
2859                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2860                }
2861            }
2862        }
2863        deserializer.deserialize_any(GeneratedVisitor)
2864    }
2865}
2866impl serde::Serialize for DisableCommitEpochRequest {
2867    #[allow(deprecated)]
2868    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2869    where
2870        S: serde::Serializer,
2871    {
2872        use serde::ser::SerializeStruct;
2873        let len = 0;
2874        let struct_ser = serializer.serialize_struct("hummock.DisableCommitEpochRequest", len)?;
2875        struct_ser.end()
2876    }
2877}
2878impl<'de> serde::Deserialize<'de> for DisableCommitEpochRequest {
2879    #[allow(deprecated)]
2880    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2881    where
2882        D: serde::Deserializer<'de>,
2883    {
2884        const FIELDS: &[&str] = &[
2885        ];
2886
2887        #[allow(clippy::enum_variant_names)]
2888        enum GeneratedField {
2889        }
2890        impl<'de> serde::Deserialize<'de> for GeneratedField {
2891            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2892            where
2893                D: serde::Deserializer<'de>,
2894            {
2895                struct GeneratedVisitor;
2896
2897                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2898                    type Value = GeneratedField;
2899
2900                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2901                        write!(formatter, "expected one of: {:?}", &FIELDS)
2902                    }
2903
2904                    #[allow(unused_variables)]
2905                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2906                    where
2907                        E: serde::de::Error,
2908                    {
2909                            Err(serde::de::Error::unknown_field(value, FIELDS))
2910                    }
2911                }
2912                deserializer.deserialize_identifier(GeneratedVisitor)
2913            }
2914        }
2915        struct GeneratedVisitor;
2916        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2917            type Value = DisableCommitEpochRequest;
2918
2919            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2920                formatter.write_str("struct hummock.DisableCommitEpochRequest")
2921            }
2922
2923            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DisableCommitEpochRequest, V::Error>
2924                where
2925                    V: serde::de::MapAccess<'de>,
2926            {
2927                while map_.next_key::<GeneratedField>()?.is_some() {
2928                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
2929                }
2930                Ok(DisableCommitEpochRequest {
2931                })
2932            }
2933        }
2934        deserializer.deserialize_struct("hummock.DisableCommitEpochRequest", FIELDS, GeneratedVisitor)
2935    }
2936}
2937impl serde::Serialize for DisableCommitEpochResponse {
2938    #[allow(deprecated)]
2939    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2940    where
2941        S: serde::Serializer,
2942    {
2943        use serde::ser::SerializeStruct;
2944        let mut len = 0;
2945        if self.current_version.is_some() {
2946            len += 1;
2947        }
2948        let mut struct_ser = serializer.serialize_struct("hummock.DisableCommitEpochResponse", len)?;
2949        if let Some(v) = self.current_version.as_ref() {
2950            struct_ser.serialize_field("currentVersion", v)?;
2951        }
2952        struct_ser.end()
2953    }
2954}
2955impl<'de> serde::Deserialize<'de> for DisableCommitEpochResponse {
2956    #[allow(deprecated)]
2957    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2958    where
2959        D: serde::Deserializer<'de>,
2960    {
2961        const FIELDS: &[&str] = &[
2962            "current_version",
2963            "currentVersion",
2964        ];
2965
2966        #[allow(clippy::enum_variant_names)]
2967        enum GeneratedField {
2968            CurrentVersion,
2969        }
2970        impl<'de> serde::Deserialize<'de> for GeneratedField {
2971            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2972            where
2973                D: serde::Deserializer<'de>,
2974            {
2975                struct GeneratedVisitor;
2976
2977                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2978                    type Value = GeneratedField;
2979
2980                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2981                        write!(formatter, "expected one of: {:?}", &FIELDS)
2982                    }
2983
2984                    #[allow(unused_variables)]
2985                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2986                    where
2987                        E: serde::de::Error,
2988                    {
2989                        match value {
2990                            "currentVersion" | "current_version" => Ok(GeneratedField::CurrentVersion),
2991                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2992                        }
2993                    }
2994                }
2995                deserializer.deserialize_identifier(GeneratedVisitor)
2996            }
2997        }
2998        struct GeneratedVisitor;
2999        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3000            type Value = DisableCommitEpochResponse;
3001
3002            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3003                formatter.write_str("struct hummock.DisableCommitEpochResponse")
3004            }
3005
3006            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DisableCommitEpochResponse, V::Error>
3007                where
3008                    V: serde::de::MapAccess<'de>,
3009            {
3010                let mut current_version__ = None;
3011                while let Some(k) = map_.next_key()? {
3012                    match k {
3013                        GeneratedField::CurrentVersion => {
3014                            if current_version__.is_some() {
3015                                return Err(serde::de::Error::duplicate_field("currentVersion"));
3016                            }
3017                            current_version__ = map_.next_value()?;
3018                        }
3019                    }
3020                }
3021                Ok(DisableCommitEpochResponse {
3022                    current_version: current_version__,
3023                })
3024            }
3025        }
3026        deserializer.deserialize_struct("hummock.DisableCommitEpochResponse", FIELDS, GeneratedVisitor)
3027    }
3028}
3029impl serde::Serialize for EpochNewChangeLog {
3030    #[allow(deprecated)]
3031    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3032    where
3033        S: serde::Serializer,
3034    {
3035        use serde::ser::SerializeStruct;
3036        let mut len = 0;
3037        if !self.old_value.is_empty() {
3038            len += 1;
3039        }
3040        if !self.new_value.is_empty() {
3041            len += 1;
3042        }
3043        if !self.epochs.is_empty() {
3044            len += 1;
3045        }
3046        let mut struct_ser = serializer.serialize_struct("hummock.EpochNewChangeLog", len)?;
3047        if !self.old_value.is_empty() {
3048            struct_ser.serialize_field("oldValue", &self.old_value)?;
3049        }
3050        if !self.new_value.is_empty() {
3051            struct_ser.serialize_field("newValue", &self.new_value)?;
3052        }
3053        if !self.epochs.is_empty() {
3054            struct_ser.serialize_field("epochs", &self.epochs.iter().map(ToString::to_string).collect::<Vec<_>>())?;
3055        }
3056        struct_ser.end()
3057    }
3058}
3059impl<'de> serde::Deserialize<'de> for EpochNewChangeLog {
3060    #[allow(deprecated)]
3061    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3062    where
3063        D: serde::Deserializer<'de>,
3064    {
3065        const FIELDS: &[&str] = &[
3066            "old_value",
3067            "oldValue",
3068            "new_value",
3069            "newValue",
3070            "epochs",
3071        ];
3072
3073        #[allow(clippy::enum_variant_names)]
3074        enum GeneratedField {
3075            OldValue,
3076            NewValue,
3077            Epochs,
3078        }
3079        impl<'de> serde::Deserialize<'de> for GeneratedField {
3080            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3081            where
3082                D: serde::Deserializer<'de>,
3083            {
3084                struct GeneratedVisitor;
3085
3086                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3087                    type Value = GeneratedField;
3088
3089                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3090                        write!(formatter, "expected one of: {:?}", &FIELDS)
3091                    }
3092
3093                    #[allow(unused_variables)]
3094                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3095                    where
3096                        E: serde::de::Error,
3097                    {
3098                        match value {
3099                            "oldValue" | "old_value" => Ok(GeneratedField::OldValue),
3100                            "newValue" | "new_value" => Ok(GeneratedField::NewValue),
3101                            "epochs" => Ok(GeneratedField::Epochs),
3102                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3103                        }
3104                    }
3105                }
3106                deserializer.deserialize_identifier(GeneratedVisitor)
3107            }
3108        }
3109        struct GeneratedVisitor;
3110        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3111            type Value = EpochNewChangeLog;
3112
3113            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3114                formatter.write_str("struct hummock.EpochNewChangeLog")
3115            }
3116
3117            fn visit_map<V>(self, mut map_: V) -> std::result::Result<EpochNewChangeLog, V::Error>
3118                where
3119                    V: serde::de::MapAccess<'de>,
3120            {
3121                let mut old_value__ = None;
3122                let mut new_value__ = None;
3123                let mut epochs__ = None;
3124                while let Some(k) = map_.next_key()? {
3125                    match k {
3126                        GeneratedField::OldValue => {
3127                            if old_value__.is_some() {
3128                                return Err(serde::de::Error::duplicate_field("oldValue"));
3129                            }
3130                            old_value__ = Some(map_.next_value()?);
3131                        }
3132                        GeneratedField::NewValue => {
3133                            if new_value__.is_some() {
3134                                return Err(serde::de::Error::duplicate_field("newValue"));
3135                            }
3136                            new_value__ = Some(map_.next_value()?);
3137                        }
3138                        GeneratedField::Epochs => {
3139                            if epochs__.is_some() {
3140                                return Err(serde::de::Error::duplicate_field("epochs"));
3141                            }
3142                            epochs__ = 
3143                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3144                                    .into_iter().map(|x| x.0).collect())
3145                            ;
3146                        }
3147                    }
3148                }
3149                Ok(EpochNewChangeLog {
3150                    old_value: old_value__.unwrap_or_default(),
3151                    new_value: new_value__.unwrap_or_default(),
3152                    epochs: epochs__.unwrap_or_default(),
3153                })
3154            }
3155        }
3156        deserializer.deserialize_struct("hummock.EpochNewChangeLog", FIELDS, GeneratedVisitor)
3157    }
3158}
3159impl serde::Serialize for FlatIndex {
3160    #[allow(deprecated)]
3161    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3162    where
3163        S: serde::Serializer,
3164    {
3165        use serde::ser::SerializeStruct;
3166        let mut len = 0;
3167        if self.config.is_some() {
3168            len += 1;
3169        }
3170        if !self.vector_files.is_empty() {
3171            len += 1;
3172        }
3173        if self.next_vector_id != 0 {
3174            len += 1;
3175        }
3176        let mut struct_ser = serializer.serialize_struct("hummock.FlatIndex", len)?;
3177        if let Some(v) = self.config.as_ref() {
3178            struct_ser.serialize_field("config", v)?;
3179        }
3180        if !self.vector_files.is_empty() {
3181            struct_ser.serialize_field("vectorFiles", &self.vector_files)?;
3182        }
3183        if self.next_vector_id != 0 {
3184            #[allow(clippy::needless_borrow)]
3185            #[allow(clippy::needless_borrows_for_generic_args)]
3186            struct_ser.serialize_field("nextVectorId", ToString::to_string(&self.next_vector_id).as_str())?;
3187        }
3188        struct_ser.end()
3189    }
3190}
3191impl<'de> serde::Deserialize<'de> for FlatIndex {
3192    #[allow(deprecated)]
3193    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3194    where
3195        D: serde::Deserializer<'de>,
3196    {
3197        const FIELDS: &[&str] = &[
3198            "config",
3199            "vector_files",
3200            "vectorFiles",
3201            "next_vector_id",
3202            "nextVectorId",
3203        ];
3204
3205        #[allow(clippy::enum_variant_names)]
3206        enum GeneratedField {
3207            Config,
3208            VectorFiles,
3209            NextVectorId,
3210        }
3211        impl<'de> serde::Deserialize<'de> for GeneratedField {
3212            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3213            where
3214                D: serde::Deserializer<'de>,
3215            {
3216                struct GeneratedVisitor;
3217
3218                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3219                    type Value = GeneratedField;
3220
3221                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3222                        write!(formatter, "expected one of: {:?}", &FIELDS)
3223                    }
3224
3225                    #[allow(unused_variables)]
3226                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3227                    where
3228                        E: serde::de::Error,
3229                    {
3230                        match value {
3231                            "config" => Ok(GeneratedField::Config),
3232                            "vectorFiles" | "vector_files" => Ok(GeneratedField::VectorFiles),
3233                            "nextVectorId" | "next_vector_id" => Ok(GeneratedField::NextVectorId),
3234                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3235                        }
3236                    }
3237                }
3238                deserializer.deserialize_identifier(GeneratedVisitor)
3239            }
3240        }
3241        struct GeneratedVisitor;
3242        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3243            type Value = FlatIndex;
3244
3245            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3246                formatter.write_str("struct hummock.FlatIndex")
3247            }
3248
3249            fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlatIndex, V::Error>
3250                where
3251                    V: serde::de::MapAccess<'de>,
3252            {
3253                let mut config__ = None;
3254                let mut vector_files__ = None;
3255                let mut next_vector_id__ = None;
3256                while let Some(k) = map_.next_key()? {
3257                    match k {
3258                        GeneratedField::Config => {
3259                            if config__.is_some() {
3260                                return Err(serde::de::Error::duplicate_field("config"));
3261                            }
3262                            config__ = map_.next_value()?;
3263                        }
3264                        GeneratedField::VectorFiles => {
3265                            if vector_files__.is_some() {
3266                                return Err(serde::de::Error::duplicate_field("vectorFiles"));
3267                            }
3268                            vector_files__ = Some(map_.next_value()?);
3269                        }
3270                        GeneratedField::NextVectorId => {
3271                            if next_vector_id__.is_some() {
3272                                return Err(serde::de::Error::duplicate_field("nextVectorId"));
3273                            }
3274                            next_vector_id__ = 
3275                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3276                            ;
3277                        }
3278                    }
3279                }
3280                Ok(FlatIndex {
3281                    config: config__,
3282                    vector_files: vector_files__.unwrap_or_default(),
3283                    next_vector_id: next_vector_id__.unwrap_or_default(),
3284                })
3285            }
3286        }
3287        deserializer.deserialize_struct("hummock.FlatIndex", FIELDS, GeneratedVisitor)
3288    }
3289}
3290impl serde::Serialize for FlatIndexAdd {
3291    #[allow(deprecated)]
3292    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3293    where
3294        S: serde::Serializer,
3295    {
3296        use serde::ser::SerializeStruct;
3297        let mut len = 0;
3298        if !self.added_vector_files.is_empty() {
3299            len += 1;
3300        }
3301        if self.next_vector_id != 0 {
3302            len += 1;
3303        }
3304        let mut struct_ser = serializer.serialize_struct("hummock.FlatIndexAdd", len)?;
3305        if !self.added_vector_files.is_empty() {
3306            struct_ser.serialize_field("addedVectorFiles", &self.added_vector_files)?;
3307        }
3308        if self.next_vector_id != 0 {
3309            #[allow(clippy::needless_borrow)]
3310            #[allow(clippy::needless_borrows_for_generic_args)]
3311            struct_ser.serialize_field("nextVectorId", ToString::to_string(&self.next_vector_id).as_str())?;
3312        }
3313        struct_ser.end()
3314    }
3315}
3316impl<'de> serde::Deserialize<'de> for FlatIndexAdd {
3317    #[allow(deprecated)]
3318    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3319    where
3320        D: serde::Deserializer<'de>,
3321    {
3322        const FIELDS: &[&str] = &[
3323            "added_vector_files",
3324            "addedVectorFiles",
3325            "next_vector_id",
3326            "nextVectorId",
3327        ];
3328
3329        #[allow(clippy::enum_variant_names)]
3330        enum GeneratedField {
3331            AddedVectorFiles,
3332            NextVectorId,
3333        }
3334        impl<'de> serde::Deserialize<'de> for GeneratedField {
3335            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3336            where
3337                D: serde::Deserializer<'de>,
3338            {
3339                struct GeneratedVisitor;
3340
3341                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3342                    type Value = GeneratedField;
3343
3344                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3345                        write!(formatter, "expected one of: {:?}", &FIELDS)
3346                    }
3347
3348                    #[allow(unused_variables)]
3349                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3350                    where
3351                        E: serde::de::Error,
3352                    {
3353                        match value {
3354                            "addedVectorFiles" | "added_vector_files" => Ok(GeneratedField::AddedVectorFiles),
3355                            "nextVectorId" | "next_vector_id" => Ok(GeneratedField::NextVectorId),
3356                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3357                        }
3358                    }
3359                }
3360                deserializer.deserialize_identifier(GeneratedVisitor)
3361            }
3362        }
3363        struct GeneratedVisitor;
3364        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3365            type Value = FlatIndexAdd;
3366
3367            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3368                formatter.write_str("struct hummock.FlatIndexAdd")
3369            }
3370
3371            fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlatIndexAdd, V::Error>
3372                where
3373                    V: serde::de::MapAccess<'de>,
3374            {
3375                let mut added_vector_files__ = None;
3376                let mut next_vector_id__ = None;
3377                while let Some(k) = map_.next_key()? {
3378                    match k {
3379                        GeneratedField::AddedVectorFiles => {
3380                            if added_vector_files__.is_some() {
3381                                return Err(serde::de::Error::duplicate_field("addedVectorFiles"));
3382                            }
3383                            added_vector_files__ = Some(map_.next_value()?);
3384                        }
3385                        GeneratedField::NextVectorId => {
3386                            if next_vector_id__.is_some() {
3387                                return Err(serde::de::Error::duplicate_field("nextVectorId"));
3388                            }
3389                            next_vector_id__ = 
3390                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3391                            ;
3392                        }
3393                    }
3394                }
3395                Ok(FlatIndexAdd {
3396                    added_vector_files: added_vector_files__.unwrap_or_default(),
3397                    next_vector_id: next_vector_id__.unwrap_or_default(),
3398                })
3399            }
3400        }
3401        deserializer.deserialize_struct("hummock.FlatIndexAdd", FIELDS, GeneratedVisitor)
3402    }
3403}
3404impl serde::Serialize for FullScanTask {
3405    #[allow(deprecated)]
3406    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3407    where
3408        S: serde::Serializer,
3409    {
3410        use serde::ser::SerializeStruct;
3411        let mut len = 0;
3412        if self.sst_retention_watermark != 0 {
3413            len += 1;
3414        }
3415        if self.prefix.is_some() {
3416            len += 1;
3417        }
3418        if self.start_after.is_some() {
3419            len += 1;
3420        }
3421        if self.limit.is_some() {
3422            len += 1;
3423        }
3424        let mut struct_ser = serializer.serialize_struct("hummock.FullScanTask", len)?;
3425        if self.sst_retention_watermark != 0 {
3426            #[allow(clippy::needless_borrow)]
3427            #[allow(clippy::needless_borrows_for_generic_args)]
3428            struct_ser.serialize_field("sstRetentionWatermark", ToString::to_string(&self.sst_retention_watermark).as_str())?;
3429        }
3430        if let Some(v) = self.prefix.as_ref() {
3431            struct_ser.serialize_field("prefix", v)?;
3432        }
3433        if let Some(v) = self.start_after.as_ref() {
3434            struct_ser.serialize_field("startAfter", v)?;
3435        }
3436        if let Some(v) = self.limit.as_ref() {
3437            #[allow(clippy::needless_borrow)]
3438            #[allow(clippy::needless_borrows_for_generic_args)]
3439            struct_ser.serialize_field("limit", ToString::to_string(&v).as_str())?;
3440        }
3441        struct_ser.end()
3442    }
3443}
3444impl<'de> serde::Deserialize<'de> for FullScanTask {
3445    #[allow(deprecated)]
3446    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3447    where
3448        D: serde::Deserializer<'de>,
3449    {
3450        const FIELDS: &[&str] = &[
3451            "sst_retention_watermark",
3452            "sstRetentionWatermark",
3453            "prefix",
3454            "start_after",
3455            "startAfter",
3456            "limit",
3457        ];
3458
3459        #[allow(clippy::enum_variant_names)]
3460        enum GeneratedField {
3461            SstRetentionWatermark,
3462            Prefix,
3463            StartAfter,
3464            Limit,
3465        }
3466        impl<'de> serde::Deserialize<'de> for GeneratedField {
3467            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3468            where
3469                D: serde::Deserializer<'de>,
3470            {
3471                struct GeneratedVisitor;
3472
3473                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3474                    type Value = GeneratedField;
3475
3476                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3477                        write!(formatter, "expected one of: {:?}", &FIELDS)
3478                    }
3479
3480                    #[allow(unused_variables)]
3481                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3482                    where
3483                        E: serde::de::Error,
3484                    {
3485                        match value {
3486                            "sstRetentionWatermark" | "sst_retention_watermark" => Ok(GeneratedField::SstRetentionWatermark),
3487                            "prefix" => Ok(GeneratedField::Prefix),
3488                            "startAfter" | "start_after" => Ok(GeneratedField::StartAfter),
3489                            "limit" => Ok(GeneratedField::Limit),
3490                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3491                        }
3492                    }
3493                }
3494                deserializer.deserialize_identifier(GeneratedVisitor)
3495            }
3496        }
3497        struct GeneratedVisitor;
3498        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3499            type Value = FullScanTask;
3500
3501            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3502                formatter.write_str("struct hummock.FullScanTask")
3503            }
3504
3505            fn visit_map<V>(self, mut map_: V) -> std::result::Result<FullScanTask, V::Error>
3506                where
3507                    V: serde::de::MapAccess<'de>,
3508            {
3509                let mut sst_retention_watermark__ = None;
3510                let mut prefix__ = None;
3511                let mut start_after__ = None;
3512                let mut limit__ = None;
3513                while let Some(k) = map_.next_key()? {
3514                    match k {
3515                        GeneratedField::SstRetentionWatermark => {
3516                            if sst_retention_watermark__.is_some() {
3517                                return Err(serde::de::Error::duplicate_field("sstRetentionWatermark"));
3518                            }
3519                            sst_retention_watermark__ = 
3520                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3521                            ;
3522                        }
3523                        GeneratedField::Prefix => {
3524                            if prefix__.is_some() {
3525                                return Err(serde::de::Error::duplicate_field("prefix"));
3526                            }
3527                            prefix__ = map_.next_value()?;
3528                        }
3529                        GeneratedField::StartAfter => {
3530                            if start_after__.is_some() {
3531                                return Err(serde::de::Error::duplicate_field("startAfter"));
3532                            }
3533                            start_after__ = map_.next_value()?;
3534                        }
3535                        GeneratedField::Limit => {
3536                            if limit__.is_some() {
3537                                return Err(serde::de::Error::duplicate_field("limit"));
3538                            }
3539                            limit__ = 
3540                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3541                            ;
3542                        }
3543                    }
3544                }
3545                Ok(FullScanTask {
3546                    sst_retention_watermark: sst_retention_watermark__.unwrap_or_default(),
3547                    prefix: prefix__,
3548                    start_after: start_after__,
3549                    limit: limit__,
3550                })
3551            }
3552        }
3553        deserializer.deserialize_struct("hummock.FullScanTask", FIELDS, GeneratedVisitor)
3554    }
3555}
3556impl serde::Serialize for GetAssignedCompactTaskNumRequest {
3557    #[allow(deprecated)]
3558    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3559    where
3560        S: serde::Serializer,
3561    {
3562        use serde::ser::SerializeStruct;
3563        let len = 0;
3564        let struct_ser = serializer.serialize_struct("hummock.GetAssignedCompactTaskNumRequest", len)?;
3565        struct_ser.end()
3566    }
3567}
3568impl<'de> serde::Deserialize<'de> for GetAssignedCompactTaskNumRequest {
3569    #[allow(deprecated)]
3570    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3571    where
3572        D: serde::Deserializer<'de>,
3573    {
3574        const FIELDS: &[&str] = &[
3575        ];
3576
3577        #[allow(clippy::enum_variant_names)]
3578        enum GeneratedField {
3579        }
3580        impl<'de> serde::Deserialize<'de> for GeneratedField {
3581            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3582            where
3583                D: serde::Deserializer<'de>,
3584            {
3585                struct GeneratedVisitor;
3586
3587                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3588                    type Value = GeneratedField;
3589
3590                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3591                        write!(formatter, "expected one of: {:?}", &FIELDS)
3592                    }
3593
3594                    #[allow(unused_variables)]
3595                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3596                    where
3597                        E: serde::de::Error,
3598                    {
3599                            Err(serde::de::Error::unknown_field(value, FIELDS))
3600                    }
3601                }
3602                deserializer.deserialize_identifier(GeneratedVisitor)
3603            }
3604        }
3605        struct GeneratedVisitor;
3606        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3607            type Value = GetAssignedCompactTaskNumRequest;
3608
3609            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3610                formatter.write_str("struct hummock.GetAssignedCompactTaskNumRequest")
3611            }
3612
3613            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetAssignedCompactTaskNumRequest, V::Error>
3614                where
3615                    V: serde::de::MapAccess<'de>,
3616            {
3617                while map_.next_key::<GeneratedField>()?.is_some() {
3618                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
3619                }
3620                Ok(GetAssignedCompactTaskNumRequest {
3621                })
3622            }
3623        }
3624        deserializer.deserialize_struct("hummock.GetAssignedCompactTaskNumRequest", FIELDS, GeneratedVisitor)
3625    }
3626}
3627impl serde::Serialize for GetAssignedCompactTaskNumResponse {
3628    #[allow(deprecated)]
3629    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3630    where
3631        S: serde::Serializer,
3632    {
3633        use serde::ser::SerializeStruct;
3634        let mut len = 0;
3635        if self.num_tasks != 0 {
3636            len += 1;
3637        }
3638        let mut struct_ser = serializer.serialize_struct("hummock.GetAssignedCompactTaskNumResponse", len)?;
3639        if self.num_tasks != 0 {
3640            struct_ser.serialize_field("numTasks", &self.num_tasks)?;
3641        }
3642        struct_ser.end()
3643    }
3644}
3645impl<'de> serde::Deserialize<'de> for GetAssignedCompactTaskNumResponse {
3646    #[allow(deprecated)]
3647    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3648    where
3649        D: serde::Deserializer<'de>,
3650    {
3651        const FIELDS: &[&str] = &[
3652            "num_tasks",
3653            "numTasks",
3654        ];
3655
3656        #[allow(clippy::enum_variant_names)]
3657        enum GeneratedField {
3658            NumTasks,
3659        }
3660        impl<'de> serde::Deserialize<'de> for GeneratedField {
3661            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3662            where
3663                D: serde::Deserializer<'de>,
3664            {
3665                struct GeneratedVisitor;
3666
3667                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3668                    type Value = GeneratedField;
3669
3670                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3671                        write!(formatter, "expected one of: {:?}", &FIELDS)
3672                    }
3673
3674                    #[allow(unused_variables)]
3675                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3676                    where
3677                        E: serde::de::Error,
3678                    {
3679                        match value {
3680                            "numTasks" | "num_tasks" => Ok(GeneratedField::NumTasks),
3681                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3682                        }
3683                    }
3684                }
3685                deserializer.deserialize_identifier(GeneratedVisitor)
3686            }
3687        }
3688        struct GeneratedVisitor;
3689        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3690            type Value = GetAssignedCompactTaskNumResponse;
3691
3692            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3693                formatter.write_str("struct hummock.GetAssignedCompactTaskNumResponse")
3694            }
3695
3696            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetAssignedCompactTaskNumResponse, V::Error>
3697                where
3698                    V: serde::de::MapAccess<'de>,
3699            {
3700                let mut num_tasks__ = None;
3701                while let Some(k) = map_.next_key()? {
3702                    match k {
3703                        GeneratedField::NumTasks => {
3704                            if num_tasks__.is_some() {
3705                                return Err(serde::de::Error::duplicate_field("numTasks"));
3706                            }
3707                            num_tasks__ = 
3708                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3709                            ;
3710                        }
3711                    }
3712                }
3713                Ok(GetAssignedCompactTaskNumResponse {
3714                    num_tasks: num_tasks__.unwrap_or_default(),
3715                })
3716            }
3717        }
3718        deserializer.deserialize_struct("hummock.GetAssignedCompactTaskNumResponse", FIELDS, GeneratedVisitor)
3719    }
3720}
3721impl serde::Serialize for GetCompactionScoreRequest {
3722    #[allow(deprecated)]
3723    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3724    where
3725        S: serde::Serializer,
3726    {
3727        use serde::ser::SerializeStruct;
3728        let mut len = 0;
3729        if self.compaction_group_id != 0 {
3730            len += 1;
3731        }
3732        let mut struct_ser = serializer.serialize_struct("hummock.GetCompactionScoreRequest", len)?;
3733        if self.compaction_group_id != 0 {
3734            #[allow(clippy::needless_borrow)]
3735            #[allow(clippy::needless_borrows_for_generic_args)]
3736            struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
3737        }
3738        struct_ser.end()
3739    }
3740}
3741impl<'de> serde::Deserialize<'de> for GetCompactionScoreRequest {
3742    #[allow(deprecated)]
3743    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3744    where
3745        D: serde::Deserializer<'de>,
3746    {
3747        const FIELDS: &[&str] = &[
3748            "compaction_group_id",
3749            "compactionGroupId",
3750        ];
3751
3752        #[allow(clippy::enum_variant_names)]
3753        enum GeneratedField {
3754            CompactionGroupId,
3755        }
3756        impl<'de> serde::Deserialize<'de> for GeneratedField {
3757            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3758            where
3759                D: serde::Deserializer<'de>,
3760            {
3761                struct GeneratedVisitor;
3762
3763                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3764                    type Value = GeneratedField;
3765
3766                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3767                        write!(formatter, "expected one of: {:?}", &FIELDS)
3768                    }
3769
3770                    #[allow(unused_variables)]
3771                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3772                    where
3773                        E: serde::de::Error,
3774                    {
3775                        match value {
3776                            "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
3777                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3778                        }
3779                    }
3780                }
3781                deserializer.deserialize_identifier(GeneratedVisitor)
3782            }
3783        }
3784        struct GeneratedVisitor;
3785        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3786            type Value = GetCompactionScoreRequest;
3787
3788            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3789                formatter.write_str("struct hummock.GetCompactionScoreRequest")
3790            }
3791
3792            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCompactionScoreRequest, V::Error>
3793                where
3794                    V: serde::de::MapAccess<'de>,
3795            {
3796                let mut compaction_group_id__ = None;
3797                while let Some(k) = map_.next_key()? {
3798                    match k {
3799                        GeneratedField::CompactionGroupId => {
3800                            if compaction_group_id__.is_some() {
3801                                return Err(serde::de::Error::duplicate_field("compactionGroupId"));
3802                            }
3803                            compaction_group_id__ = 
3804                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3805                            ;
3806                        }
3807                    }
3808                }
3809                Ok(GetCompactionScoreRequest {
3810                    compaction_group_id: compaction_group_id__.unwrap_or_default(),
3811                })
3812            }
3813        }
3814        deserializer.deserialize_struct("hummock.GetCompactionScoreRequest", FIELDS, GeneratedVisitor)
3815    }
3816}
3817impl serde::Serialize for GetCompactionScoreResponse {
3818    #[allow(deprecated)]
3819    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3820    where
3821        S: serde::Serializer,
3822    {
3823        use serde::ser::SerializeStruct;
3824        let mut len = 0;
3825        if self.compaction_group_id != 0 {
3826            len += 1;
3827        }
3828        if !self.scores.is_empty() {
3829            len += 1;
3830        }
3831        let mut struct_ser = serializer.serialize_struct("hummock.GetCompactionScoreResponse", len)?;
3832        if self.compaction_group_id != 0 {
3833            #[allow(clippy::needless_borrow)]
3834            #[allow(clippy::needless_borrows_for_generic_args)]
3835            struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
3836        }
3837        if !self.scores.is_empty() {
3838            struct_ser.serialize_field("scores", &self.scores)?;
3839        }
3840        struct_ser.end()
3841    }
3842}
3843impl<'de> serde::Deserialize<'de> for GetCompactionScoreResponse {
3844    #[allow(deprecated)]
3845    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3846    where
3847        D: serde::Deserializer<'de>,
3848    {
3849        const FIELDS: &[&str] = &[
3850            "compaction_group_id",
3851            "compactionGroupId",
3852            "scores",
3853        ];
3854
3855        #[allow(clippy::enum_variant_names)]
3856        enum GeneratedField {
3857            CompactionGroupId,
3858            Scores,
3859        }
3860        impl<'de> serde::Deserialize<'de> for GeneratedField {
3861            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3862            where
3863                D: serde::Deserializer<'de>,
3864            {
3865                struct GeneratedVisitor;
3866
3867                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3868                    type Value = GeneratedField;
3869
3870                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3871                        write!(formatter, "expected one of: {:?}", &FIELDS)
3872                    }
3873
3874                    #[allow(unused_variables)]
3875                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3876                    where
3877                        E: serde::de::Error,
3878                    {
3879                        match value {
3880                            "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
3881                            "scores" => Ok(GeneratedField::Scores),
3882                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3883                        }
3884                    }
3885                }
3886                deserializer.deserialize_identifier(GeneratedVisitor)
3887            }
3888        }
3889        struct GeneratedVisitor;
3890        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3891            type Value = GetCompactionScoreResponse;
3892
3893            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3894                formatter.write_str("struct hummock.GetCompactionScoreResponse")
3895            }
3896
3897            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCompactionScoreResponse, V::Error>
3898                where
3899                    V: serde::de::MapAccess<'de>,
3900            {
3901                let mut compaction_group_id__ = None;
3902                let mut scores__ = None;
3903                while let Some(k) = map_.next_key()? {
3904                    match k {
3905                        GeneratedField::CompactionGroupId => {
3906                            if compaction_group_id__.is_some() {
3907                                return Err(serde::de::Error::duplicate_field("compactionGroupId"));
3908                            }
3909                            compaction_group_id__ = 
3910                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3911                            ;
3912                        }
3913                        GeneratedField::Scores => {
3914                            if scores__.is_some() {
3915                                return Err(serde::de::Error::duplicate_field("scores"));
3916                            }
3917                            scores__ = Some(map_.next_value()?);
3918                        }
3919                    }
3920                }
3921                Ok(GetCompactionScoreResponse {
3922                    compaction_group_id: compaction_group_id__.unwrap_or_default(),
3923                    scores: scores__.unwrap_or_default(),
3924                })
3925            }
3926        }
3927        deserializer.deserialize_struct("hummock.GetCompactionScoreResponse", FIELDS, GeneratedVisitor)
3928    }
3929}
3930impl serde::Serialize for get_compaction_score_response::PickerInfo {
3931    #[allow(deprecated)]
3932    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3933    where
3934        S: serde::Serializer,
3935    {
3936        use serde::ser::SerializeStruct;
3937        let mut len = 0;
3938        if self.score != 0 {
3939            len += 1;
3940        }
3941        if self.select_level != 0 {
3942            len += 1;
3943        }
3944        if self.target_level != 0 {
3945            len += 1;
3946        }
3947        if !self.picker_type.is_empty() {
3948            len += 1;
3949        }
3950        let mut struct_ser = serializer.serialize_struct("hummock.GetCompactionScoreResponse.PickerInfo", len)?;
3951        if self.score != 0 {
3952            #[allow(clippy::needless_borrow)]
3953            #[allow(clippy::needless_borrows_for_generic_args)]
3954            struct_ser.serialize_field("score", ToString::to_string(&self.score).as_str())?;
3955        }
3956        if self.select_level != 0 {
3957            #[allow(clippy::needless_borrow)]
3958            #[allow(clippy::needless_borrows_for_generic_args)]
3959            struct_ser.serialize_field("selectLevel", ToString::to_string(&self.select_level).as_str())?;
3960        }
3961        if self.target_level != 0 {
3962            #[allow(clippy::needless_borrow)]
3963            #[allow(clippy::needless_borrows_for_generic_args)]
3964            struct_ser.serialize_field("targetLevel", ToString::to_string(&self.target_level).as_str())?;
3965        }
3966        if !self.picker_type.is_empty() {
3967            struct_ser.serialize_field("pickerType", &self.picker_type)?;
3968        }
3969        struct_ser.end()
3970    }
3971}
3972impl<'de> serde::Deserialize<'de> for get_compaction_score_response::PickerInfo {
3973    #[allow(deprecated)]
3974    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3975    where
3976        D: serde::Deserializer<'de>,
3977    {
3978        const FIELDS: &[&str] = &[
3979            "score",
3980            "select_level",
3981            "selectLevel",
3982            "target_level",
3983            "targetLevel",
3984            "picker_type",
3985            "pickerType",
3986        ];
3987
3988        #[allow(clippy::enum_variant_names)]
3989        enum GeneratedField {
3990            Score,
3991            SelectLevel,
3992            TargetLevel,
3993            PickerType,
3994        }
3995        impl<'de> serde::Deserialize<'de> for GeneratedField {
3996            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3997            where
3998                D: serde::Deserializer<'de>,
3999            {
4000                struct GeneratedVisitor;
4001
4002                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4003                    type Value = GeneratedField;
4004
4005                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4006                        write!(formatter, "expected one of: {:?}", &FIELDS)
4007                    }
4008
4009                    #[allow(unused_variables)]
4010                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4011                    where
4012                        E: serde::de::Error,
4013                    {
4014                        match value {
4015                            "score" => Ok(GeneratedField::Score),
4016                            "selectLevel" | "select_level" => Ok(GeneratedField::SelectLevel),
4017                            "targetLevel" | "target_level" => Ok(GeneratedField::TargetLevel),
4018                            "pickerType" | "picker_type" => Ok(GeneratedField::PickerType),
4019                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4020                        }
4021                    }
4022                }
4023                deserializer.deserialize_identifier(GeneratedVisitor)
4024            }
4025        }
4026        struct GeneratedVisitor;
4027        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4028            type Value = get_compaction_score_response::PickerInfo;
4029
4030            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4031                formatter.write_str("struct hummock.GetCompactionScoreResponse.PickerInfo")
4032            }
4033
4034            fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_compaction_score_response::PickerInfo, V::Error>
4035                where
4036                    V: serde::de::MapAccess<'de>,
4037            {
4038                let mut score__ = None;
4039                let mut select_level__ = None;
4040                let mut target_level__ = None;
4041                let mut picker_type__ = None;
4042                while let Some(k) = map_.next_key()? {
4043                    match k {
4044                        GeneratedField::Score => {
4045                            if score__.is_some() {
4046                                return Err(serde::de::Error::duplicate_field("score"));
4047                            }
4048                            score__ = 
4049                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4050                            ;
4051                        }
4052                        GeneratedField::SelectLevel => {
4053                            if select_level__.is_some() {
4054                                return Err(serde::de::Error::duplicate_field("selectLevel"));
4055                            }
4056                            select_level__ = 
4057                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4058                            ;
4059                        }
4060                        GeneratedField::TargetLevel => {
4061                            if target_level__.is_some() {
4062                                return Err(serde::de::Error::duplicate_field("targetLevel"));
4063                            }
4064                            target_level__ = 
4065                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4066                            ;
4067                        }
4068                        GeneratedField::PickerType => {
4069                            if picker_type__.is_some() {
4070                                return Err(serde::de::Error::duplicate_field("pickerType"));
4071                            }
4072                            picker_type__ = Some(map_.next_value()?);
4073                        }
4074                    }
4075                }
4076                Ok(get_compaction_score_response::PickerInfo {
4077                    score: score__.unwrap_or_default(),
4078                    select_level: select_level__.unwrap_or_default(),
4079                    target_level: target_level__.unwrap_or_default(),
4080                    picker_type: picker_type__.unwrap_or_default(),
4081                })
4082            }
4083        }
4084        deserializer.deserialize_struct("hummock.GetCompactionScoreResponse.PickerInfo", FIELDS, GeneratedVisitor)
4085    }
4086}
4087impl serde::Serialize for GetCurrentVersionRequest {
4088    #[allow(deprecated)]
4089    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4090    where
4091        S: serde::Serializer,
4092    {
4093        use serde::ser::SerializeStruct;
4094        let len = 0;
4095        let struct_ser = serializer.serialize_struct("hummock.GetCurrentVersionRequest", len)?;
4096        struct_ser.end()
4097    }
4098}
4099impl<'de> serde::Deserialize<'de> for GetCurrentVersionRequest {
4100    #[allow(deprecated)]
4101    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4102    where
4103        D: serde::Deserializer<'de>,
4104    {
4105        const FIELDS: &[&str] = &[
4106        ];
4107
4108        #[allow(clippy::enum_variant_names)]
4109        enum GeneratedField {
4110        }
4111        impl<'de> serde::Deserialize<'de> for GeneratedField {
4112            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4113            where
4114                D: serde::Deserializer<'de>,
4115            {
4116                struct GeneratedVisitor;
4117
4118                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4119                    type Value = GeneratedField;
4120
4121                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4122                        write!(formatter, "expected one of: {:?}", &FIELDS)
4123                    }
4124
4125                    #[allow(unused_variables)]
4126                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4127                    where
4128                        E: serde::de::Error,
4129                    {
4130                            Err(serde::de::Error::unknown_field(value, FIELDS))
4131                    }
4132                }
4133                deserializer.deserialize_identifier(GeneratedVisitor)
4134            }
4135        }
4136        struct GeneratedVisitor;
4137        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4138            type Value = GetCurrentVersionRequest;
4139
4140            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4141                formatter.write_str("struct hummock.GetCurrentVersionRequest")
4142            }
4143
4144            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCurrentVersionRequest, V::Error>
4145                where
4146                    V: serde::de::MapAccess<'de>,
4147            {
4148                while map_.next_key::<GeneratedField>()?.is_some() {
4149                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
4150                }
4151                Ok(GetCurrentVersionRequest {
4152                })
4153            }
4154        }
4155        deserializer.deserialize_struct("hummock.GetCurrentVersionRequest", FIELDS, GeneratedVisitor)
4156    }
4157}
4158impl serde::Serialize for GetCurrentVersionResponse {
4159    #[allow(deprecated)]
4160    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4161    where
4162        S: serde::Serializer,
4163    {
4164        use serde::ser::SerializeStruct;
4165        let mut len = 0;
4166        if self.status.is_some() {
4167            len += 1;
4168        }
4169        if self.current_version.is_some() {
4170            len += 1;
4171        }
4172        let mut struct_ser = serializer.serialize_struct("hummock.GetCurrentVersionResponse", len)?;
4173        if let Some(v) = self.status.as_ref() {
4174            struct_ser.serialize_field("status", v)?;
4175        }
4176        if let Some(v) = self.current_version.as_ref() {
4177            struct_ser.serialize_field("currentVersion", v)?;
4178        }
4179        struct_ser.end()
4180    }
4181}
4182impl<'de> serde::Deserialize<'de> for GetCurrentVersionResponse {
4183    #[allow(deprecated)]
4184    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4185    where
4186        D: serde::Deserializer<'de>,
4187    {
4188        const FIELDS: &[&str] = &[
4189            "status",
4190            "current_version",
4191            "currentVersion",
4192        ];
4193
4194        #[allow(clippy::enum_variant_names)]
4195        enum GeneratedField {
4196            Status,
4197            CurrentVersion,
4198        }
4199        impl<'de> serde::Deserialize<'de> for GeneratedField {
4200            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4201            where
4202                D: serde::Deserializer<'de>,
4203            {
4204                struct GeneratedVisitor;
4205
4206                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4207                    type Value = GeneratedField;
4208
4209                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4210                        write!(formatter, "expected one of: {:?}", &FIELDS)
4211                    }
4212
4213                    #[allow(unused_variables)]
4214                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4215                    where
4216                        E: serde::de::Error,
4217                    {
4218                        match value {
4219                            "status" => Ok(GeneratedField::Status),
4220                            "currentVersion" | "current_version" => Ok(GeneratedField::CurrentVersion),
4221                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4222                        }
4223                    }
4224                }
4225                deserializer.deserialize_identifier(GeneratedVisitor)
4226            }
4227        }
4228        struct GeneratedVisitor;
4229        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4230            type Value = GetCurrentVersionResponse;
4231
4232            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4233                formatter.write_str("struct hummock.GetCurrentVersionResponse")
4234            }
4235
4236            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCurrentVersionResponse, V::Error>
4237                where
4238                    V: serde::de::MapAccess<'de>,
4239            {
4240                let mut status__ = None;
4241                let mut current_version__ = None;
4242                while let Some(k) = map_.next_key()? {
4243                    match k {
4244                        GeneratedField::Status => {
4245                            if status__.is_some() {
4246                                return Err(serde::de::Error::duplicate_field("status"));
4247                            }
4248                            status__ = map_.next_value()?;
4249                        }
4250                        GeneratedField::CurrentVersion => {
4251                            if current_version__.is_some() {
4252                                return Err(serde::de::Error::duplicate_field("currentVersion"));
4253                            }
4254                            current_version__ = map_.next_value()?;
4255                        }
4256                    }
4257                }
4258                Ok(GetCurrentVersionResponse {
4259                    status: status__,
4260                    current_version: current_version__,
4261                })
4262            }
4263        }
4264        deserializer.deserialize_struct("hummock.GetCurrentVersionResponse", FIELDS, GeneratedVisitor)
4265    }
4266}
4267impl serde::Serialize for GetNewObjectIdsRequest {
4268    #[allow(deprecated)]
4269    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4270    where
4271        S: serde::Serializer,
4272    {
4273        use serde::ser::SerializeStruct;
4274        let mut len = 0;
4275        if self.number != 0 {
4276            len += 1;
4277        }
4278        let mut struct_ser = serializer.serialize_struct("hummock.GetNewObjectIdsRequest", len)?;
4279        if self.number != 0 {
4280            struct_ser.serialize_field("number", &self.number)?;
4281        }
4282        struct_ser.end()
4283    }
4284}
4285impl<'de> serde::Deserialize<'de> for GetNewObjectIdsRequest {
4286    #[allow(deprecated)]
4287    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4288    where
4289        D: serde::Deserializer<'de>,
4290    {
4291        const FIELDS: &[&str] = &[
4292            "number",
4293        ];
4294
4295        #[allow(clippy::enum_variant_names)]
4296        enum GeneratedField {
4297            Number,
4298        }
4299        impl<'de> serde::Deserialize<'de> for GeneratedField {
4300            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4301            where
4302                D: serde::Deserializer<'de>,
4303            {
4304                struct GeneratedVisitor;
4305
4306                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4307                    type Value = GeneratedField;
4308
4309                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4310                        write!(formatter, "expected one of: {:?}", &FIELDS)
4311                    }
4312
4313                    #[allow(unused_variables)]
4314                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4315                    where
4316                        E: serde::de::Error,
4317                    {
4318                        match value {
4319                            "number" => Ok(GeneratedField::Number),
4320                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4321                        }
4322                    }
4323                }
4324                deserializer.deserialize_identifier(GeneratedVisitor)
4325            }
4326        }
4327        struct GeneratedVisitor;
4328        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4329            type Value = GetNewObjectIdsRequest;
4330
4331            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4332                formatter.write_str("struct hummock.GetNewObjectIdsRequest")
4333            }
4334
4335            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetNewObjectIdsRequest, V::Error>
4336                where
4337                    V: serde::de::MapAccess<'de>,
4338            {
4339                let mut number__ = None;
4340                while let Some(k) = map_.next_key()? {
4341                    match k {
4342                        GeneratedField::Number => {
4343                            if number__.is_some() {
4344                                return Err(serde::de::Error::duplicate_field("number"));
4345                            }
4346                            number__ = 
4347                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4348                            ;
4349                        }
4350                    }
4351                }
4352                Ok(GetNewObjectIdsRequest {
4353                    number: number__.unwrap_or_default(),
4354                })
4355            }
4356        }
4357        deserializer.deserialize_struct("hummock.GetNewObjectIdsRequest", FIELDS, GeneratedVisitor)
4358    }
4359}
4360impl serde::Serialize for GetNewObjectIdsResponse {
4361    #[allow(deprecated)]
4362    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4363    where
4364        S: serde::Serializer,
4365    {
4366        use serde::ser::SerializeStruct;
4367        let mut len = 0;
4368        if self.status.is_some() {
4369            len += 1;
4370        }
4371        if self.start_id != 0 {
4372            len += 1;
4373        }
4374        if self.end_id != 0 {
4375            len += 1;
4376        }
4377        let mut struct_ser = serializer.serialize_struct("hummock.GetNewObjectIdsResponse", len)?;
4378        if let Some(v) = self.status.as_ref() {
4379            struct_ser.serialize_field("status", v)?;
4380        }
4381        if self.start_id != 0 {
4382            #[allow(clippy::needless_borrow)]
4383            #[allow(clippy::needless_borrows_for_generic_args)]
4384            struct_ser.serialize_field("startId", ToString::to_string(&self.start_id).as_str())?;
4385        }
4386        if self.end_id != 0 {
4387            #[allow(clippy::needless_borrow)]
4388            #[allow(clippy::needless_borrows_for_generic_args)]
4389            struct_ser.serialize_field("endId", ToString::to_string(&self.end_id).as_str())?;
4390        }
4391        struct_ser.end()
4392    }
4393}
4394impl<'de> serde::Deserialize<'de> for GetNewObjectIdsResponse {
4395    #[allow(deprecated)]
4396    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4397    where
4398        D: serde::Deserializer<'de>,
4399    {
4400        const FIELDS: &[&str] = &[
4401            "status",
4402            "start_id",
4403            "startId",
4404            "end_id",
4405            "endId",
4406        ];
4407
4408        #[allow(clippy::enum_variant_names)]
4409        enum GeneratedField {
4410            Status,
4411            StartId,
4412            EndId,
4413        }
4414        impl<'de> serde::Deserialize<'de> for GeneratedField {
4415            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4416            where
4417                D: serde::Deserializer<'de>,
4418            {
4419                struct GeneratedVisitor;
4420
4421                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4422                    type Value = GeneratedField;
4423
4424                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4425                        write!(formatter, "expected one of: {:?}", &FIELDS)
4426                    }
4427
4428                    #[allow(unused_variables)]
4429                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4430                    where
4431                        E: serde::de::Error,
4432                    {
4433                        match value {
4434                            "status" => Ok(GeneratedField::Status),
4435                            "startId" | "start_id" => Ok(GeneratedField::StartId),
4436                            "endId" | "end_id" => Ok(GeneratedField::EndId),
4437                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4438                        }
4439                    }
4440                }
4441                deserializer.deserialize_identifier(GeneratedVisitor)
4442            }
4443        }
4444        struct GeneratedVisitor;
4445        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4446            type Value = GetNewObjectIdsResponse;
4447
4448            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4449                formatter.write_str("struct hummock.GetNewObjectIdsResponse")
4450            }
4451
4452            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetNewObjectIdsResponse, V::Error>
4453                where
4454                    V: serde::de::MapAccess<'de>,
4455            {
4456                let mut status__ = None;
4457                let mut start_id__ = None;
4458                let mut end_id__ = None;
4459                while let Some(k) = map_.next_key()? {
4460                    match k {
4461                        GeneratedField::Status => {
4462                            if status__.is_some() {
4463                                return Err(serde::de::Error::duplicate_field("status"));
4464                            }
4465                            status__ = map_.next_value()?;
4466                        }
4467                        GeneratedField::StartId => {
4468                            if start_id__.is_some() {
4469                                return Err(serde::de::Error::duplicate_field("startId"));
4470                            }
4471                            start_id__ = 
4472                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4473                            ;
4474                        }
4475                        GeneratedField::EndId => {
4476                            if end_id__.is_some() {
4477                                return Err(serde::de::Error::duplicate_field("endId"));
4478                            }
4479                            end_id__ = 
4480                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4481                            ;
4482                        }
4483                    }
4484                }
4485                Ok(GetNewObjectIdsResponse {
4486                    status: status__,
4487                    start_id: start_id__.unwrap_or_default(),
4488                    end_id: end_id__.unwrap_or_default(),
4489                })
4490            }
4491        }
4492        deserializer.deserialize_struct("hummock.GetNewObjectIdsResponse", FIELDS, GeneratedVisitor)
4493    }
4494}
4495impl serde::Serialize for GetVersionByEpochRequest {
4496    #[allow(deprecated)]
4497    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4498    where
4499        S: serde::Serializer,
4500    {
4501        use serde::ser::SerializeStruct;
4502        let mut len = 0;
4503        if self.epoch != 0 {
4504            len += 1;
4505        }
4506        if self.table_id != 0 {
4507            len += 1;
4508        }
4509        let mut struct_ser = serializer.serialize_struct("hummock.GetVersionByEpochRequest", len)?;
4510        if self.epoch != 0 {
4511            #[allow(clippy::needless_borrow)]
4512            #[allow(clippy::needless_borrows_for_generic_args)]
4513            struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
4514        }
4515        if self.table_id != 0 {
4516            struct_ser.serialize_field("tableId", &self.table_id)?;
4517        }
4518        struct_ser.end()
4519    }
4520}
4521impl<'de> serde::Deserialize<'de> for GetVersionByEpochRequest {
4522    #[allow(deprecated)]
4523    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4524    where
4525        D: serde::Deserializer<'de>,
4526    {
4527        const FIELDS: &[&str] = &[
4528            "epoch",
4529            "table_id",
4530            "tableId",
4531        ];
4532
4533        #[allow(clippy::enum_variant_names)]
4534        enum GeneratedField {
4535            Epoch,
4536            TableId,
4537        }
4538        impl<'de> serde::Deserialize<'de> for GeneratedField {
4539            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4540            where
4541                D: serde::Deserializer<'de>,
4542            {
4543                struct GeneratedVisitor;
4544
4545                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4546                    type Value = GeneratedField;
4547
4548                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4549                        write!(formatter, "expected one of: {:?}", &FIELDS)
4550                    }
4551
4552                    #[allow(unused_variables)]
4553                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4554                    where
4555                        E: serde::de::Error,
4556                    {
4557                        match value {
4558                            "epoch" => Ok(GeneratedField::Epoch),
4559                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
4560                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4561                        }
4562                    }
4563                }
4564                deserializer.deserialize_identifier(GeneratedVisitor)
4565            }
4566        }
4567        struct GeneratedVisitor;
4568        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4569            type Value = GetVersionByEpochRequest;
4570
4571            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4572                formatter.write_str("struct hummock.GetVersionByEpochRequest")
4573            }
4574
4575            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetVersionByEpochRequest, V::Error>
4576                where
4577                    V: serde::de::MapAccess<'de>,
4578            {
4579                let mut epoch__ = None;
4580                let mut table_id__ = None;
4581                while let Some(k) = map_.next_key()? {
4582                    match k {
4583                        GeneratedField::Epoch => {
4584                            if epoch__.is_some() {
4585                                return Err(serde::de::Error::duplicate_field("epoch"));
4586                            }
4587                            epoch__ = 
4588                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4589                            ;
4590                        }
4591                        GeneratedField::TableId => {
4592                            if table_id__.is_some() {
4593                                return Err(serde::de::Error::duplicate_field("tableId"));
4594                            }
4595                            table_id__ = 
4596                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4597                            ;
4598                        }
4599                    }
4600                }
4601                Ok(GetVersionByEpochRequest {
4602                    epoch: epoch__.unwrap_or_default(),
4603                    table_id: table_id__.unwrap_or_default(),
4604                })
4605            }
4606        }
4607        deserializer.deserialize_struct("hummock.GetVersionByEpochRequest", FIELDS, GeneratedVisitor)
4608    }
4609}
4610impl serde::Serialize for GetVersionByEpochResponse {
4611    #[allow(deprecated)]
4612    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4613    where
4614        S: serde::Serializer,
4615    {
4616        use serde::ser::SerializeStruct;
4617        let mut len = 0;
4618        if self.version.is_some() {
4619            len += 1;
4620        }
4621        let mut struct_ser = serializer.serialize_struct("hummock.GetVersionByEpochResponse", len)?;
4622        if let Some(v) = self.version.as_ref() {
4623            struct_ser.serialize_field("version", v)?;
4624        }
4625        struct_ser.end()
4626    }
4627}
4628impl<'de> serde::Deserialize<'de> for GetVersionByEpochResponse {
4629    #[allow(deprecated)]
4630    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4631    where
4632        D: serde::Deserializer<'de>,
4633    {
4634        const FIELDS: &[&str] = &[
4635            "version",
4636        ];
4637
4638        #[allow(clippy::enum_variant_names)]
4639        enum GeneratedField {
4640            Version,
4641        }
4642        impl<'de> serde::Deserialize<'de> for GeneratedField {
4643            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4644            where
4645                D: serde::Deserializer<'de>,
4646            {
4647                struct GeneratedVisitor;
4648
4649                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4650                    type Value = GeneratedField;
4651
4652                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4653                        write!(formatter, "expected one of: {:?}", &FIELDS)
4654                    }
4655
4656                    #[allow(unused_variables)]
4657                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4658                    where
4659                        E: serde::de::Error,
4660                    {
4661                        match value {
4662                            "version" => Ok(GeneratedField::Version),
4663                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4664                        }
4665                    }
4666                }
4667                deserializer.deserialize_identifier(GeneratedVisitor)
4668            }
4669        }
4670        struct GeneratedVisitor;
4671        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4672            type Value = GetVersionByEpochResponse;
4673
4674            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4675                formatter.write_str("struct hummock.GetVersionByEpochResponse")
4676            }
4677
4678            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetVersionByEpochResponse, V::Error>
4679                where
4680                    V: serde::de::MapAccess<'de>,
4681            {
4682                let mut version__ = None;
4683                while let Some(k) = map_.next_key()? {
4684                    match k {
4685                        GeneratedField::Version => {
4686                            if version__.is_some() {
4687                                return Err(serde::de::Error::duplicate_field("version"));
4688                            }
4689                            version__ = map_.next_value()?;
4690                        }
4691                    }
4692                }
4693                Ok(GetVersionByEpochResponse {
4694                    version: version__,
4695                })
4696            }
4697        }
4698        deserializer.deserialize_struct("hummock.GetVersionByEpochResponse", FIELDS, GeneratedVisitor)
4699    }
4700}
4701impl serde::Serialize for GroupConstruct {
4702    #[allow(deprecated)]
4703    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4704    where
4705        S: serde::Serializer,
4706    {
4707        use serde::ser::SerializeStruct;
4708        let mut len = 0;
4709        if self.group_config.is_some() {
4710            len += 1;
4711        }
4712        if self.parent_group_id != 0 {
4713            len += 1;
4714        }
4715        if !self.table_ids.is_empty() {
4716            len += 1;
4717        }
4718        if self.group_id != 0 {
4719            len += 1;
4720        }
4721        if self.new_sst_start_id != 0 {
4722            len += 1;
4723        }
4724        if self.version != 0 {
4725            len += 1;
4726        }
4727        if self.split_key.is_some() {
4728            len += 1;
4729        }
4730        let mut struct_ser = serializer.serialize_struct("hummock.GroupConstruct", len)?;
4731        if let Some(v) = self.group_config.as_ref() {
4732            struct_ser.serialize_field("groupConfig", v)?;
4733        }
4734        if self.parent_group_id != 0 {
4735            #[allow(clippy::needless_borrow)]
4736            #[allow(clippy::needless_borrows_for_generic_args)]
4737            struct_ser.serialize_field("parentGroupId", ToString::to_string(&self.parent_group_id).as_str())?;
4738        }
4739        if !self.table_ids.is_empty() {
4740            struct_ser.serialize_field("tableIds", &self.table_ids)?;
4741        }
4742        if self.group_id != 0 {
4743            #[allow(clippy::needless_borrow)]
4744            #[allow(clippy::needless_borrows_for_generic_args)]
4745            struct_ser.serialize_field("groupId", ToString::to_string(&self.group_id).as_str())?;
4746        }
4747        if self.new_sst_start_id != 0 {
4748            #[allow(clippy::needless_borrow)]
4749            #[allow(clippy::needless_borrows_for_generic_args)]
4750            struct_ser.serialize_field("newSstStartId", ToString::to_string(&self.new_sst_start_id).as_str())?;
4751        }
4752        if self.version != 0 {
4753            let v = CompatibilityVersion::try_from(self.version)
4754                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
4755            struct_ser.serialize_field("version", &v)?;
4756        }
4757        if let Some(v) = self.split_key.as_ref() {
4758            #[allow(clippy::needless_borrow)]
4759            #[allow(clippy::needless_borrows_for_generic_args)]
4760            struct_ser.serialize_field("splitKey", pbjson::private::base64::encode(&v).as_str())?;
4761        }
4762        struct_ser.end()
4763    }
4764}
4765impl<'de> serde::Deserialize<'de> for GroupConstruct {
4766    #[allow(deprecated)]
4767    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4768    where
4769        D: serde::Deserializer<'de>,
4770    {
4771        const FIELDS: &[&str] = &[
4772            "group_config",
4773            "groupConfig",
4774            "parent_group_id",
4775            "parentGroupId",
4776            "table_ids",
4777            "tableIds",
4778            "group_id",
4779            "groupId",
4780            "new_sst_start_id",
4781            "newSstStartId",
4782            "version",
4783            "split_key",
4784            "splitKey",
4785        ];
4786
4787        #[allow(clippy::enum_variant_names)]
4788        enum GeneratedField {
4789            GroupConfig,
4790            ParentGroupId,
4791            TableIds,
4792            GroupId,
4793            NewSstStartId,
4794            Version,
4795            SplitKey,
4796        }
4797        impl<'de> serde::Deserialize<'de> for GeneratedField {
4798            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4799            where
4800                D: serde::Deserializer<'de>,
4801            {
4802                struct GeneratedVisitor;
4803
4804                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4805                    type Value = GeneratedField;
4806
4807                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4808                        write!(formatter, "expected one of: {:?}", &FIELDS)
4809                    }
4810
4811                    #[allow(unused_variables)]
4812                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4813                    where
4814                        E: serde::de::Error,
4815                    {
4816                        match value {
4817                            "groupConfig" | "group_config" => Ok(GeneratedField::GroupConfig),
4818                            "parentGroupId" | "parent_group_id" => Ok(GeneratedField::ParentGroupId),
4819                            "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
4820                            "groupId" | "group_id" => Ok(GeneratedField::GroupId),
4821                            "newSstStartId" | "new_sst_start_id" => Ok(GeneratedField::NewSstStartId),
4822                            "version" => Ok(GeneratedField::Version),
4823                            "splitKey" | "split_key" => Ok(GeneratedField::SplitKey),
4824                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4825                        }
4826                    }
4827                }
4828                deserializer.deserialize_identifier(GeneratedVisitor)
4829            }
4830        }
4831        struct GeneratedVisitor;
4832        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4833            type Value = GroupConstruct;
4834
4835            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4836                formatter.write_str("struct hummock.GroupConstruct")
4837            }
4838
4839            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupConstruct, V::Error>
4840                where
4841                    V: serde::de::MapAccess<'de>,
4842            {
4843                let mut group_config__ = None;
4844                let mut parent_group_id__ = None;
4845                let mut table_ids__ = None;
4846                let mut group_id__ = None;
4847                let mut new_sst_start_id__ = None;
4848                let mut version__ = None;
4849                let mut split_key__ = None;
4850                while let Some(k) = map_.next_key()? {
4851                    match k {
4852                        GeneratedField::GroupConfig => {
4853                            if group_config__.is_some() {
4854                                return Err(serde::de::Error::duplicate_field("groupConfig"));
4855                            }
4856                            group_config__ = map_.next_value()?;
4857                        }
4858                        GeneratedField::ParentGroupId => {
4859                            if parent_group_id__.is_some() {
4860                                return Err(serde::de::Error::duplicate_field("parentGroupId"));
4861                            }
4862                            parent_group_id__ = 
4863                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4864                            ;
4865                        }
4866                        GeneratedField::TableIds => {
4867                            if table_ids__.is_some() {
4868                                return Err(serde::de::Error::duplicate_field("tableIds"));
4869                            }
4870                            table_ids__ = 
4871                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4872                                    .into_iter().map(|x| x.0).collect())
4873                            ;
4874                        }
4875                        GeneratedField::GroupId => {
4876                            if group_id__.is_some() {
4877                                return Err(serde::de::Error::duplicate_field("groupId"));
4878                            }
4879                            group_id__ = 
4880                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4881                            ;
4882                        }
4883                        GeneratedField::NewSstStartId => {
4884                            if new_sst_start_id__.is_some() {
4885                                return Err(serde::de::Error::duplicate_field("newSstStartId"));
4886                            }
4887                            new_sst_start_id__ = 
4888                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4889                            ;
4890                        }
4891                        GeneratedField::Version => {
4892                            if version__.is_some() {
4893                                return Err(serde::de::Error::duplicate_field("version"));
4894                            }
4895                            version__ = Some(map_.next_value::<CompatibilityVersion>()? as i32);
4896                        }
4897                        GeneratedField::SplitKey => {
4898                            if split_key__.is_some() {
4899                                return Err(serde::de::Error::duplicate_field("splitKey"));
4900                            }
4901                            split_key__ = 
4902                                map_.next_value::<::std::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| x.0)
4903                            ;
4904                        }
4905                    }
4906                }
4907                Ok(GroupConstruct {
4908                    group_config: group_config__,
4909                    parent_group_id: parent_group_id__.unwrap_or_default(),
4910                    table_ids: table_ids__.unwrap_or_default(),
4911                    group_id: group_id__.unwrap_or_default(),
4912                    new_sst_start_id: new_sst_start_id__.unwrap_or_default(),
4913                    version: version__.unwrap_or_default(),
4914                    split_key: split_key__,
4915                })
4916            }
4917        }
4918        deserializer.deserialize_struct("hummock.GroupConstruct", FIELDS, GeneratedVisitor)
4919    }
4920}
4921impl serde::Serialize for GroupDelta {
4922    #[allow(deprecated)]
4923    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4924    where
4925        S: serde::Serializer,
4926    {
4927        use serde::ser::SerializeStruct;
4928        let mut len = 0;
4929        if self.delta_type.is_some() {
4930            len += 1;
4931        }
4932        let mut struct_ser = serializer.serialize_struct("hummock.GroupDelta", len)?;
4933        if let Some(v) = self.delta_type.as_ref() {
4934            match v {
4935                group_delta::DeltaType::IntraLevel(v) => {
4936                    struct_ser.serialize_field("intraLevel", v)?;
4937                }
4938                group_delta::DeltaType::GroupConstruct(v) => {
4939                    struct_ser.serialize_field("groupConstruct", v)?;
4940                }
4941                group_delta::DeltaType::GroupDestroy(v) => {
4942                    struct_ser.serialize_field("groupDestroy", v)?;
4943                }
4944                group_delta::DeltaType::GroupMerge(v) => {
4945                    struct_ser.serialize_field("groupMerge", v)?;
4946                }
4947                group_delta::DeltaType::NewL0SubLevel(v) => {
4948                    struct_ser.serialize_field("newL0SubLevel", v)?;
4949                }
4950                group_delta::DeltaType::TruncateTables(v) => {
4951                    struct_ser.serialize_field("truncateTables", v)?;
4952                }
4953            }
4954        }
4955        struct_ser.end()
4956    }
4957}
4958impl<'de> serde::Deserialize<'de> for GroupDelta {
4959    #[allow(deprecated)]
4960    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4961    where
4962        D: serde::Deserializer<'de>,
4963    {
4964        const FIELDS: &[&str] = &[
4965            "intra_level",
4966            "intraLevel",
4967            "group_construct",
4968            "groupConstruct",
4969            "group_destroy",
4970            "groupDestroy",
4971            "group_merge",
4972            "groupMerge",
4973            "new_l0_sub_level",
4974            "newL0SubLevel",
4975            "truncate_tables",
4976            "truncateTables",
4977        ];
4978
4979        #[allow(clippy::enum_variant_names)]
4980        enum GeneratedField {
4981            IntraLevel,
4982            GroupConstruct,
4983            GroupDestroy,
4984            GroupMerge,
4985            NewL0SubLevel,
4986            TruncateTables,
4987        }
4988        impl<'de> serde::Deserialize<'de> for GeneratedField {
4989            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4990            where
4991                D: serde::Deserializer<'de>,
4992            {
4993                struct GeneratedVisitor;
4994
4995                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4996                    type Value = GeneratedField;
4997
4998                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4999                        write!(formatter, "expected one of: {:?}", &FIELDS)
5000                    }
5001
5002                    #[allow(unused_variables)]
5003                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5004                    where
5005                        E: serde::de::Error,
5006                    {
5007                        match value {
5008                            "intraLevel" | "intra_level" => Ok(GeneratedField::IntraLevel),
5009                            "groupConstruct" | "group_construct" => Ok(GeneratedField::GroupConstruct),
5010                            "groupDestroy" | "group_destroy" => Ok(GeneratedField::GroupDestroy),
5011                            "groupMerge" | "group_merge" => Ok(GeneratedField::GroupMerge),
5012                            "newL0SubLevel" | "new_l0_sub_level" => Ok(GeneratedField::NewL0SubLevel),
5013                            "truncateTables" | "truncate_tables" => Ok(GeneratedField::TruncateTables),
5014                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5015                        }
5016                    }
5017                }
5018                deserializer.deserialize_identifier(GeneratedVisitor)
5019            }
5020        }
5021        struct GeneratedVisitor;
5022        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5023            type Value = GroupDelta;
5024
5025            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5026                formatter.write_str("struct hummock.GroupDelta")
5027            }
5028
5029            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupDelta, V::Error>
5030                where
5031                    V: serde::de::MapAccess<'de>,
5032            {
5033                let mut delta_type__ = None;
5034                while let Some(k) = map_.next_key()? {
5035                    match k {
5036                        GeneratedField::IntraLevel => {
5037                            if delta_type__.is_some() {
5038                                return Err(serde::de::Error::duplicate_field("intraLevel"));
5039                            }
5040                            delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::IntraLevel)
5041;
5042                        }
5043                        GeneratedField::GroupConstruct => {
5044                            if delta_type__.is_some() {
5045                                return Err(serde::de::Error::duplicate_field("groupConstruct"));
5046                            }
5047                            delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::GroupConstruct)
5048;
5049                        }
5050                        GeneratedField::GroupDestroy => {
5051                            if delta_type__.is_some() {
5052                                return Err(serde::de::Error::duplicate_field("groupDestroy"));
5053                            }
5054                            delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::GroupDestroy)
5055;
5056                        }
5057                        GeneratedField::GroupMerge => {
5058                            if delta_type__.is_some() {
5059                                return Err(serde::de::Error::duplicate_field("groupMerge"));
5060                            }
5061                            delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::GroupMerge)
5062;
5063                        }
5064                        GeneratedField::NewL0SubLevel => {
5065                            if delta_type__.is_some() {
5066                                return Err(serde::de::Error::duplicate_field("newL0SubLevel"));
5067                            }
5068                            delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::NewL0SubLevel)
5069;
5070                        }
5071                        GeneratedField::TruncateTables => {
5072                            if delta_type__.is_some() {
5073                                return Err(serde::de::Error::duplicate_field("truncateTables"));
5074                            }
5075                            delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::TruncateTables)
5076;
5077                        }
5078                    }
5079                }
5080                Ok(GroupDelta {
5081                    delta_type: delta_type__,
5082                })
5083            }
5084        }
5085        deserializer.deserialize_struct("hummock.GroupDelta", FIELDS, GeneratedVisitor)
5086    }
5087}
5088impl serde::Serialize for GroupDestroy {
5089    #[allow(deprecated)]
5090    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5091    where
5092        S: serde::Serializer,
5093    {
5094        use serde::ser::SerializeStruct;
5095        let len = 0;
5096        let struct_ser = serializer.serialize_struct("hummock.GroupDestroy", len)?;
5097        struct_ser.end()
5098    }
5099}
5100impl<'de> serde::Deserialize<'de> for GroupDestroy {
5101    #[allow(deprecated)]
5102    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5103    where
5104        D: serde::Deserializer<'de>,
5105    {
5106        const FIELDS: &[&str] = &[
5107        ];
5108
5109        #[allow(clippy::enum_variant_names)]
5110        enum GeneratedField {
5111        }
5112        impl<'de> serde::Deserialize<'de> for GeneratedField {
5113            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5114            where
5115                D: serde::Deserializer<'de>,
5116            {
5117                struct GeneratedVisitor;
5118
5119                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5120                    type Value = GeneratedField;
5121
5122                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5123                        write!(formatter, "expected one of: {:?}", &FIELDS)
5124                    }
5125
5126                    #[allow(unused_variables)]
5127                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5128                    where
5129                        E: serde::de::Error,
5130                    {
5131                            Err(serde::de::Error::unknown_field(value, FIELDS))
5132                    }
5133                }
5134                deserializer.deserialize_identifier(GeneratedVisitor)
5135            }
5136        }
5137        struct GeneratedVisitor;
5138        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5139            type Value = GroupDestroy;
5140
5141            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5142                formatter.write_str("struct hummock.GroupDestroy")
5143            }
5144
5145            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupDestroy, V::Error>
5146                where
5147                    V: serde::de::MapAccess<'de>,
5148            {
5149                while map_.next_key::<GeneratedField>()?.is_some() {
5150                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
5151                }
5152                Ok(GroupDestroy {
5153                })
5154            }
5155        }
5156        deserializer.deserialize_struct("hummock.GroupDestroy", FIELDS, GeneratedVisitor)
5157    }
5158}
5159impl serde::Serialize for GroupMerge {
5160    #[allow(deprecated)]
5161    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5162    where
5163        S: serde::Serializer,
5164    {
5165        use serde::ser::SerializeStruct;
5166        let mut len = 0;
5167        if self.left_group_id != 0 {
5168            len += 1;
5169        }
5170        if self.right_group_id != 0 {
5171            len += 1;
5172        }
5173        let mut struct_ser = serializer.serialize_struct("hummock.GroupMerge", len)?;
5174        if self.left_group_id != 0 {
5175            #[allow(clippy::needless_borrow)]
5176            #[allow(clippy::needless_borrows_for_generic_args)]
5177            struct_ser.serialize_field("leftGroupId", ToString::to_string(&self.left_group_id).as_str())?;
5178        }
5179        if self.right_group_id != 0 {
5180            #[allow(clippy::needless_borrow)]
5181            #[allow(clippy::needless_borrows_for_generic_args)]
5182            struct_ser.serialize_field("rightGroupId", ToString::to_string(&self.right_group_id).as_str())?;
5183        }
5184        struct_ser.end()
5185    }
5186}
5187impl<'de> serde::Deserialize<'de> for GroupMerge {
5188    #[allow(deprecated)]
5189    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5190    where
5191        D: serde::Deserializer<'de>,
5192    {
5193        const FIELDS: &[&str] = &[
5194            "left_group_id",
5195            "leftGroupId",
5196            "right_group_id",
5197            "rightGroupId",
5198        ];
5199
5200        #[allow(clippy::enum_variant_names)]
5201        enum GeneratedField {
5202            LeftGroupId,
5203            RightGroupId,
5204        }
5205        impl<'de> serde::Deserialize<'de> for GeneratedField {
5206            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5207            where
5208                D: serde::Deserializer<'de>,
5209            {
5210                struct GeneratedVisitor;
5211
5212                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5213                    type Value = GeneratedField;
5214
5215                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5216                        write!(formatter, "expected one of: {:?}", &FIELDS)
5217                    }
5218
5219                    #[allow(unused_variables)]
5220                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5221                    where
5222                        E: serde::de::Error,
5223                    {
5224                        match value {
5225                            "leftGroupId" | "left_group_id" => Ok(GeneratedField::LeftGroupId),
5226                            "rightGroupId" | "right_group_id" => Ok(GeneratedField::RightGroupId),
5227                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5228                        }
5229                    }
5230                }
5231                deserializer.deserialize_identifier(GeneratedVisitor)
5232            }
5233        }
5234        struct GeneratedVisitor;
5235        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5236            type Value = GroupMerge;
5237
5238            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5239                formatter.write_str("struct hummock.GroupMerge")
5240            }
5241
5242            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupMerge, V::Error>
5243                where
5244                    V: serde::de::MapAccess<'de>,
5245            {
5246                let mut left_group_id__ = None;
5247                let mut right_group_id__ = None;
5248                while let Some(k) = map_.next_key()? {
5249                    match k {
5250                        GeneratedField::LeftGroupId => {
5251                            if left_group_id__.is_some() {
5252                                return Err(serde::de::Error::duplicate_field("leftGroupId"));
5253                            }
5254                            left_group_id__ = 
5255                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5256                            ;
5257                        }
5258                        GeneratedField::RightGroupId => {
5259                            if right_group_id__.is_some() {
5260                                return Err(serde::de::Error::duplicate_field("rightGroupId"));
5261                            }
5262                            right_group_id__ = 
5263                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5264                            ;
5265                        }
5266                    }
5267                }
5268                Ok(GroupMerge {
5269                    left_group_id: left_group_id__.unwrap_or_default(),
5270                    right_group_id: right_group_id__.unwrap_or_default(),
5271                })
5272            }
5273        }
5274        deserializer.deserialize_struct("hummock.GroupMerge", FIELDS, GeneratedVisitor)
5275    }
5276}
5277impl serde::Serialize for HnswFlatIndex {
5278    #[allow(deprecated)]
5279    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5280    where
5281        S: serde::Serializer,
5282    {
5283        use serde::ser::SerializeStruct;
5284        let mut len = 0;
5285        if self.config.is_some() {
5286            len += 1;
5287        }
5288        if !self.vector_files.is_empty() {
5289            len += 1;
5290        }
5291        if self.next_vector_id != 0 {
5292            len += 1;
5293        }
5294        if self.graph_file.is_some() {
5295            len += 1;
5296        }
5297        let mut struct_ser = serializer.serialize_struct("hummock.HnswFlatIndex", len)?;
5298        if let Some(v) = self.config.as_ref() {
5299            struct_ser.serialize_field("config", v)?;
5300        }
5301        if !self.vector_files.is_empty() {
5302            struct_ser.serialize_field("vectorFiles", &self.vector_files)?;
5303        }
5304        if self.next_vector_id != 0 {
5305            #[allow(clippy::needless_borrow)]
5306            #[allow(clippy::needless_borrows_for_generic_args)]
5307            struct_ser.serialize_field("nextVectorId", ToString::to_string(&self.next_vector_id).as_str())?;
5308        }
5309        if let Some(v) = self.graph_file.as_ref() {
5310            struct_ser.serialize_field("graphFile", v)?;
5311        }
5312        struct_ser.end()
5313    }
5314}
5315impl<'de> serde::Deserialize<'de> for HnswFlatIndex {
5316    #[allow(deprecated)]
5317    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5318    where
5319        D: serde::Deserializer<'de>,
5320    {
5321        const FIELDS: &[&str] = &[
5322            "config",
5323            "vector_files",
5324            "vectorFiles",
5325            "next_vector_id",
5326            "nextVectorId",
5327            "graph_file",
5328            "graphFile",
5329        ];
5330
5331        #[allow(clippy::enum_variant_names)]
5332        enum GeneratedField {
5333            Config,
5334            VectorFiles,
5335            NextVectorId,
5336            GraphFile,
5337        }
5338        impl<'de> serde::Deserialize<'de> for GeneratedField {
5339            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5340            where
5341                D: serde::Deserializer<'de>,
5342            {
5343                struct GeneratedVisitor;
5344
5345                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5346                    type Value = GeneratedField;
5347
5348                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5349                        write!(formatter, "expected one of: {:?}", &FIELDS)
5350                    }
5351
5352                    #[allow(unused_variables)]
5353                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5354                    where
5355                        E: serde::de::Error,
5356                    {
5357                        match value {
5358                            "config" => Ok(GeneratedField::Config),
5359                            "vectorFiles" | "vector_files" => Ok(GeneratedField::VectorFiles),
5360                            "nextVectorId" | "next_vector_id" => Ok(GeneratedField::NextVectorId),
5361                            "graphFile" | "graph_file" => Ok(GeneratedField::GraphFile),
5362                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5363                        }
5364                    }
5365                }
5366                deserializer.deserialize_identifier(GeneratedVisitor)
5367            }
5368        }
5369        struct GeneratedVisitor;
5370        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5371            type Value = HnswFlatIndex;
5372
5373            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5374                formatter.write_str("struct hummock.HnswFlatIndex")
5375            }
5376
5377            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HnswFlatIndex, V::Error>
5378                where
5379                    V: serde::de::MapAccess<'de>,
5380            {
5381                let mut config__ = None;
5382                let mut vector_files__ = None;
5383                let mut next_vector_id__ = None;
5384                let mut graph_file__ = None;
5385                while let Some(k) = map_.next_key()? {
5386                    match k {
5387                        GeneratedField::Config => {
5388                            if config__.is_some() {
5389                                return Err(serde::de::Error::duplicate_field("config"));
5390                            }
5391                            config__ = map_.next_value()?;
5392                        }
5393                        GeneratedField::VectorFiles => {
5394                            if vector_files__.is_some() {
5395                                return Err(serde::de::Error::duplicate_field("vectorFiles"));
5396                            }
5397                            vector_files__ = Some(map_.next_value()?);
5398                        }
5399                        GeneratedField::NextVectorId => {
5400                            if next_vector_id__.is_some() {
5401                                return Err(serde::de::Error::duplicate_field("nextVectorId"));
5402                            }
5403                            next_vector_id__ = 
5404                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5405                            ;
5406                        }
5407                        GeneratedField::GraphFile => {
5408                            if graph_file__.is_some() {
5409                                return Err(serde::de::Error::duplicate_field("graphFile"));
5410                            }
5411                            graph_file__ = map_.next_value()?;
5412                        }
5413                    }
5414                }
5415                Ok(HnswFlatIndex {
5416                    config: config__,
5417                    vector_files: vector_files__.unwrap_or_default(),
5418                    next_vector_id: next_vector_id__.unwrap_or_default(),
5419                    graph_file: graph_file__,
5420                })
5421            }
5422        }
5423        deserializer.deserialize_struct("hummock.HnswFlatIndex", FIELDS, GeneratedVisitor)
5424    }
5425}
5426impl serde::Serialize for HnswFlatIndexAdd {
5427    #[allow(deprecated)]
5428    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5429    where
5430        S: serde::Serializer,
5431    {
5432        use serde::ser::SerializeStruct;
5433        let mut len = 0;
5434        if !self.added_vector_files.is_empty() {
5435            len += 1;
5436        }
5437        if self.next_vector_id != 0 {
5438            len += 1;
5439        }
5440        if self.graph_file.is_some() {
5441            len += 1;
5442        }
5443        let mut struct_ser = serializer.serialize_struct("hummock.HnswFlatIndexAdd", len)?;
5444        if !self.added_vector_files.is_empty() {
5445            struct_ser.serialize_field("addedVectorFiles", &self.added_vector_files)?;
5446        }
5447        if self.next_vector_id != 0 {
5448            #[allow(clippy::needless_borrow)]
5449            #[allow(clippy::needless_borrows_for_generic_args)]
5450            struct_ser.serialize_field("nextVectorId", ToString::to_string(&self.next_vector_id).as_str())?;
5451        }
5452        if let Some(v) = self.graph_file.as_ref() {
5453            struct_ser.serialize_field("graphFile", v)?;
5454        }
5455        struct_ser.end()
5456    }
5457}
5458impl<'de> serde::Deserialize<'de> for HnswFlatIndexAdd {
5459    #[allow(deprecated)]
5460    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5461    where
5462        D: serde::Deserializer<'de>,
5463    {
5464        const FIELDS: &[&str] = &[
5465            "added_vector_files",
5466            "addedVectorFiles",
5467            "next_vector_id",
5468            "nextVectorId",
5469            "graph_file",
5470            "graphFile",
5471        ];
5472
5473        #[allow(clippy::enum_variant_names)]
5474        enum GeneratedField {
5475            AddedVectorFiles,
5476            NextVectorId,
5477            GraphFile,
5478        }
5479        impl<'de> serde::Deserialize<'de> for GeneratedField {
5480            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5481            where
5482                D: serde::Deserializer<'de>,
5483            {
5484                struct GeneratedVisitor;
5485
5486                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5487                    type Value = GeneratedField;
5488
5489                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5490                        write!(formatter, "expected one of: {:?}", &FIELDS)
5491                    }
5492
5493                    #[allow(unused_variables)]
5494                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5495                    where
5496                        E: serde::de::Error,
5497                    {
5498                        match value {
5499                            "addedVectorFiles" | "added_vector_files" => Ok(GeneratedField::AddedVectorFiles),
5500                            "nextVectorId" | "next_vector_id" => Ok(GeneratedField::NextVectorId),
5501                            "graphFile" | "graph_file" => Ok(GeneratedField::GraphFile),
5502                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5503                        }
5504                    }
5505                }
5506                deserializer.deserialize_identifier(GeneratedVisitor)
5507            }
5508        }
5509        struct GeneratedVisitor;
5510        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5511            type Value = HnswFlatIndexAdd;
5512
5513            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5514                formatter.write_str("struct hummock.HnswFlatIndexAdd")
5515            }
5516
5517            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HnswFlatIndexAdd, V::Error>
5518                where
5519                    V: serde::de::MapAccess<'de>,
5520            {
5521                let mut added_vector_files__ = None;
5522                let mut next_vector_id__ = None;
5523                let mut graph_file__ = None;
5524                while let Some(k) = map_.next_key()? {
5525                    match k {
5526                        GeneratedField::AddedVectorFiles => {
5527                            if added_vector_files__.is_some() {
5528                                return Err(serde::de::Error::duplicate_field("addedVectorFiles"));
5529                            }
5530                            added_vector_files__ = Some(map_.next_value()?);
5531                        }
5532                        GeneratedField::NextVectorId => {
5533                            if next_vector_id__.is_some() {
5534                                return Err(serde::de::Error::duplicate_field("nextVectorId"));
5535                            }
5536                            next_vector_id__ = 
5537                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5538                            ;
5539                        }
5540                        GeneratedField::GraphFile => {
5541                            if graph_file__.is_some() {
5542                                return Err(serde::de::Error::duplicate_field("graphFile"));
5543                            }
5544                            graph_file__ = map_.next_value()?;
5545                        }
5546                    }
5547                }
5548                Ok(HnswFlatIndexAdd {
5549                    added_vector_files: added_vector_files__.unwrap_or_default(),
5550                    next_vector_id: next_vector_id__.unwrap_or_default(),
5551                    graph_file: graph_file__,
5552                })
5553            }
5554        }
5555        deserializer.deserialize_struct("hummock.HnswFlatIndexAdd", FIELDS, GeneratedVisitor)
5556    }
5557}
5558impl serde::Serialize for HnswGraph {
5559    #[allow(deprecated)]
5560    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5561    where
5562        S: serde::Serializer,
5563    {
5564        use serde::ser::SerializeStruct;
5565        let mut len = 0;
5566        if !self.nodes.is_empty() {
5567            len += 1;
5568        }
5569        if self.entrypoint_id != 0 {
5570            len += 1;
5571        }
5572        let mut struct_ser = serializer.serialize_struct("hummock.HnswGraph", len)?;
5573        if !self.nodes.is_empty() {
5574            struct_ser.serialize_field("nodes", &self.nodes)?;
5575        }
5576        if self.entrypoint_id != 0 {
5577            #[allow(clippy::needless_borrow)]
5578            #[allow(clippy::needless_borrows_for_generic_args)]
5579            struct_ser.serialize_field("entrypointId", ToString::to_string(&self.entrypoint_id).as_str())?;
5580        }
5581        struct_ser.end()
5582    }
5583}
5584impl<'de> serde::Deserialize<'de> for HnswGraph {
5585    #[allow(deprecated)]
5586    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5587    where
5588        D: serde::Deserializer<'de>,
5589    {
5590        const FIELDS: &[&str] = &[
5591            "nodes",
5592            "entrypoint_id",
5593            "entrypointId",
5594        ];
5595
5596        #[allow(clippy::enum_variant_names)]
5597        enum GeneratedField {
5598            Nodes,
5599            EntrypointId,
5600        }
5601        impl<'de> serde::Deserialize<'de> for GeneratedField {
5602            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5603            where
5604                D: serde::Deserializer<'de>,
5605            {
5606                struct GeneratedVisitor;
5607
5608                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5609                    type Value = GeneratedField;
5610
5611                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5612                        write!(formatter, "expected one of: {:?}", &FIELDS)
5613                    }
5614
5615                    #[allow(unused_variables)]
5616                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5617                    where
5618                        E: serde::de::Error,
5619                    {
5620                        match value {
5621                            "nodes" => Ok(GeneratedField::Nodes),
5622                            "entrypointId" | "entrypoint_id" => Ok(GeneratedField::EntrypointId),
5623                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5624                        }
5625                    }
5626                }
5627                deserializer.deserialize_identifier(GeneratedVisitor)
5628            }
5629        }
5630        struct GeneratedVisitor;
5631        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5632            type Value = HnswGraph;
5633
5634            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5635                formatter.write_str("struct hummock.HnswGraph")
5636            }
5637
5638            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HnswGraph, V::Error>
5639                where
5640                    V: serde::de::MapAccess<'de>,
5641            {
5642                let mut nodes__ = None;
5643                let mut entrypoint_id__ = None;
5644                while let Some(k) = map_.next_key()? {
5645                    match k {
5646                        GeneratedField::Nodes => {
5647                            if nodes__.is_some() {
5648                                return Err(serde::de::Error::duplicate_field("nodes"));
5649                            }
5650                            nodes__ = Some(map_.next_value()?);
5651                        }
5652                        GeneratedField::EntrypointId => {
5653                            if entrypoint_id__.is_some() {
5654                                return Err(serde::de::Error::duplicate_field("entrypointId"));
5655                            }
5656                            entrypoint_id__ = 
5657                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5658                            ;
5659                        }
5660                    }
5661                }
5662                Ok(HnswGraph {
5663                    nodes: nodes__.unwrap_or_default(),
5664                    entrypoint_id: entrypoint_id__.unwrap_or_default(),
5665                })
5666            }
5667        }
5668        deserializer.deserialize_struct("hummock.HnswGraph", FIELDS, GeneratedVisitor)
5669    }
5670}
5671impl serde::Serialize for hnsw_graph::HnswLevel {
5672    #[allow(deprecated)]
5673    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5674    where
5675        S: serde::Serializer,
5676    {
5677        use serde::ser::SerializeStruct;
5678        let mut len = 0;
5679        if !self.neighbors.is_empty() {
5680            len += 1;
5681        }
5682        let mut struct_ser = serializer.serialize_struct("hummock.HnswGraph.HnswLevel", len)?;
5683        if !self.neighbors.is_empty() {
5684            struct_ser.serialize_field("neighbors", &self.neighbors)?;
5685        }
5686        struct_ser.end()
5687    }
5688}
5689impl<'de> serde::Deserialize<'de> for hnsw_graph::HnswLevel {
5690    #[allow(deprecated)]
5691    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5692    where
5693        D: serde::Deserializer<'de>,
5694    {
5695        const FIELDS: &[&str] = &[
5696            "neighbors",
5697        ];
5698
5699        #[allow(clippy::enum_variant_names)]
5700        enum GeneratedField {
5701            Neighbors,
5702        }
5703        impl<'de> serde::Deserialize<'de> for GeneratedField {
5704            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5705            where
5706                D: serde::Deserializer<'de>,
5707            {
5708                struct GeneratedVisitor;
5709
5710                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5711                    type Value = GeneratedField;
5712
5713                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5714                        write!(formatter, "expected one of: {:?}", &FIELDS)
5715                    }
5716
5717                    #[allow(unused_variables)]
5718                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5719                    where
5720                        E: serde::de::Error,
5721                    {
5722                        match value {
5723                            "neighbors" => Ok(GeneratedField::Neighbors),
5724                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5725                        }
5726                    }
5727                }
5728                deserializer.deserialize_identifier(GeneratedVisitor)
5729            }
5730        }
5731        struct GeneratedVisitor;
5732        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5733            type Value = hnsw_graph::HnswLevel;
5734
5735            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5736                formatter.write_str("struct hummock.HnswGraph.HnswLevel")
5737            }
5738
5739            fn visit_map<V>(self, mut map_: V) -> std::result::Result<hnsw_graph::HnswLevel, V::Error>
5740                where
5741                    V: serde::de::MapAccess<'de>,
5742            {
5743                let mut neighbors__ = None;
5744                while let Some(k) = map_.next_key()? {
5745                    match k {
5746                        GeneratedField::Neighbors => {
5747                            if neighbors__.is_some() {
5748                                return Err(serde::de::Error::duplicate_field("neighbors"));
5749                            }
5750                            neighbors__ = Some(map_.next_value()?);
5751                        }
5752                    }
5753                }
5754                Ok(hnsw_graph::HnswLevel {
5755                    neighbors: neighbors__.unwrap_or_default(),
5756                })
5757            }
5758        }
5759        deserializer.deserialize_struct("hummock.HnswGraph.HnswLevel", FIELDS, GeneratedVisitor)
5760    }
5761}
5762impl serde::Serialize for hnsw_graph::HnswNeighbor {
5763    #[allow(deprecated)]
5764    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5765    where
5766        S: serde::Serializer,
5767    {
5768        use serde::ser::SerializeStruct;
5769        let mut len = 0;
5770        if self.vector_id != 0 {
5771            len += 1;
5772        }
5773        if self.distance != 0. {
5774            len += 1;
5775        }
5776        let mut struct_ser = serializer.serialize_struct("hummock.HnswGraph.HnswNeighbor", len)?;
5777        if self.vector_id != 0 {
5778            #[allow(clippy::needless_borrow)]
5779            #[allow(clippy::needless_borrows_for_generic_args)]
5780            struct_ser.serialize_field("vectorId", ToString::to_string(&self.vector_id).as_str())?;
5781        }
5782        if self.distance != 0. {
5783            struct_ser.serialize_field("distance", &self.distance)?;
5784        }
5785        struct_ser.end()
5786    }
5787}
5788impl<'de> serde::Deserialize<'de> for hnsw_graph::HnswNeighbor {
5789    #[allow(deprecated)]
5790    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5791    where
5792        D: serde::Deserializer<'de>,
5793    {
5794        const FIELDS: &[&str] = &[
5795            "vector_id",
5796            "vectorId",
5797            "distance",
5798        ];
5799
5800        #[allow(clippy::enum_variant_names)]
5801        enum GeneratedField {
5802            VectorId,
5803            Distance,
5804        }
5805        impl<'de> serde::Deserialize<'de> for GeneratedField {
5806            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5807            where
5808                D: serde::Deserializer<'de>,
5809            {
5810                struct GeneratedVisitor;
5811
5812                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5813                    type Value = GeneratedField;
5814
5815                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5816                        write!(formatter, "expected one of: {:?}", &FIELDS)
5817                    }
5818
5819                    #[allow(unused_variables)]
5820                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5821                    where
5822                        E: serde::de::Error,
5823                    {
5824                        match value {
5825                            "vectorId" | "vector_id" => Ok(GeneratedField::VectorId),
5826                            "distance" => Ok(GeneratedField::Distance),
5827                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5828                        }
5829                    }
5830                }
5831                deserializer.deserialize_identifier(GeneratedVisitor)
5832            }
5833        }
5834        struct GeneratedVisitor;
5835        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5836            type Value = hnsw_graph::HnswNeighbor;
5837
5838            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5839                formatter.write_str("struct hummock.HnswGraph.HnswNeighbor")
5840            }
5841
5842            fn visit_map<V>(self, mut map_: V) -> std::result::Result<hnsw_graph::HnswNeighbor, V::Error>
5843                where
5844                    V: serde::de::MapAccess<'de>,
5845            {
5846                let mut vector_id__ = None;
5847                let mut distance__ = None;
5848                while let Some(k) = map_.next_key()? {
5849                    match k {
5850                        GeneratedField::VectorId => {
5851                            if vector_id__.is_some() {
5852                                return Err(serde::de::Error::duplicate_field("vectorId"));
5853                            }
5854                            vector_id__ = 
5855                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5856                            ;
5857                        }
5858                        GeneratedField::Distance => {
5859                            if distance__.is_some() {
5860                                return Err(serde::de::Error::duplicate_field("distance"));
5861                            }
5862                            distance__ = 
5863                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5864                            ;
5865                        }
5866                    }
5867                }
5868                Ok(hnsw_graph::HnswNeighbor {
5869                    vector_id: vector_id__.unwrap_or_default(),
5870                    distance: distance__.unwrap_or_default(),
5871                })
5872            }
5873        }
5874        deserializer.deserialize_struct("hummock.HnswGraph.HnswNeighbor", FIELDS, GeneratedVisitor)
5875    }
5876}
5877impl serde::Serialize for hnsw_graph::HnswNode {
5878    #[allow(deprecated)]
5879    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5880    where
5881        S: serde::Serializer,
5882    {
5883        use serde::ser::SerializeStruct;
5884        let mut len = 0;
5885        if !self.levels.is_empty() {
5886            len += 1;
5887        }
5888        let mut struct_ser = serializer.serialize_struct("hummock.HnswGraph.HnswNode", len)?;
5889        if !self.levels.is_empty() {
5890            struct_ser.serialize_field("levels", &self.levels)?;
5891        }
5892        struct_ser.end()
5893    }
5894}
5895impl<'de> serde::Deserialize<'de> for hnsw_graph::HnswNode {
5896    #[allow(deprecated)]
5897    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5898    where
5899        D: serde::Deserializer<'de>,
5900    {
5901        const FIELDS: &[&str] = &[
5902            "levels",
5903        ];
5904
5905        #[allow(clippy::enum_variant_names)]
5906        enum GeneratedField {
5907            Levels,
5908        }
5909        impl<'de> serde::Deserialize<'de> for GeneratedField {
5910            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5911            where
5912                D: serde::Deserializer<'de>,
5913            {
5914                struct GeneratedVisitor;
5915
5916                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5917                    type Value = GeneratedField;
5918
5919                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5920                        write!(formatter, "expected one of: {:?}", &FIELDS)
5921                    }
5922
5923                    #[allow(unused_variables)]
5924                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5925                    where
5926                        E: serde::de::Error,
5927                    {
5928                        match value {
5929                            "levels" => Ok(GeneratedField::Levels),
5930                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5931                        }
5932                    }
5933                }
5934                deserializer.deserialize_identifier(GeneratedVisitor)
5935            }
5936        }
5937        struct GeneratedVisitor;
5938        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5939            type Value = hnsw_graph::HnswNode;
5940
5941            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5942                formatter.write_str("struct hummock.HnswGraph.HnswNode")
5943            }
5944
5945            fn visit_map<V>(self, mut map_: V) -> std::result::Result<hnsw_graph::HnswNode, V::Error>
5946                where
5947                    V: serde::de::MapAccess<'de>,
5948            {
5949                let mut levels__ = None;
5950                while let Some(k) = map_.next_key()? {
5951                    match k {
5952                        GeneratedField::Levels => {
5953                            if levels__.is_some() {
5954                                return Err(serde::de::Error::duplicate_field("levels"));
5955                            }
5956                            levels__ = Some(map_.next_value()?);
5957                        }
5958                    }
5959                }
5960                Ok(hnsw_graph::HnswNode {
5961                    levels: levels__.unwrap_or_default(),
5962                })
5963            }
5964        }
5965        deserializer.deserialize_struct("hummock.HnswGraph.HnswNode", FIELDS, GeneratedVisitor)
5966    }
5967}
5968impl serde::Serialize for HnswGraphFileInfo {
5969    #[allow(deprecated)]
5970    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5971    where
5972        S: serde::Serializer,
5973    {
5974        use serde::ser::SerializeStruct;
5975        let mut len = 0;
5976        if self.object_id != 0 {
5977            len += 1;
5978        }
5979        if self.file_size != 0 {
5980            len += 1;
5981        }
5982        let mut struct_ser = serializer.serialize_struct("hummock.HnswGraphFileInfo", len)?;
5983        if self.object_id != 0 {
5984            #[allow(clippy::needless_borrow)]
5985            #[allow(clippy::needless_borrows_for_generic_args)]
5986            struct_ser.serialize_field("objectId", ToString::to_string(&self.object_id).as_str())?;
5987        }
5988        if self.file_size != 0 {
5989            #[allow(clippy::needless_borrow)]
5990            #[allow(clippy::needless_borrows_for_generic_args)]
5991            struct_ser.serialize_field("fileSize", ToString::to_string(&self.file_size).as_str())?;
5992        }
5993        struct_ser.end()
5994    }
5995}
5996impl<'de> serde::Deserialize<'de> for HnswGraphFileInfo {
5997    #[allow(deprecated)]
5998    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5999    where
6000        D: serde::Deserializer<'de>,
6001    {
6002        const FIELDS: &[&str] = &[
6003            "object_id",
6004            "objectId",
6005            "file_size",
6006            "fileSize",
6007        ];
6008
6009        #[allow(clippy::enum_variant_names)]
6010        enum GeneratedField {
6011            ObjectId,
6012            FileSize,
6013        }
6014        impl<'de> serde::Deserialize<'de> for GeneratedField {
6015            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6016            where
6017                D: serde::Deserializer<'de>,
6018            {
6019                struct GeneratedVisitor;
6020
6021                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6022                    type Value = GeneratedField;
6023
6024                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6025                        write!(formatter, "expected one of: {:?}", &FIELDS)
6026                    }
6027
6028                    #[allow(unused_variables)]
6029                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6030                    where
6031                        E: serde::de::Error,
6032                    {
6033                        match value {
6034                            "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
6035                            "fileSize" | "file_size" => Ok(GeneratedField::FileSize),
6036                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6037                        }
6038                    }
6039                }
6040                deserializer.deserialize_identifier(GeneratedVisitor)
6041            }
6042        }
6043        struct GeneratedVisitor;
6044        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6045            type Value = HnswGraphFileInfo;
6046
6047            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6048                formatter.write_str("struct hummock.HnswGraphFileInfo")
6049            }
6050
6051            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HnswGraphFileInfo, V::Error>
6052                where
6053                    V: serde::de::MapAccess<'de>,
6054            {
6055                let mut object_id__ = None;
6056                let mut file_size__ = None;
6057                while let Some(k) = map_.next_key()? {
6058                    match k {
6059                        GeneratedField::ObjectId => {
6060                            if object_id__.is_some() {
6061                                return Err(serde::de::Error::duplicate_field("objectId"));
6062                            }
6063                            object_id__ = 
6064                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6065                            ;
6066                        }
6067                        GeneratedField::FileSize => {
6068                            if file_size__.is_some() {
6069                                return Err(serde::de::Error::duplicate_field("fileSize"));
6070                            }
6071                            file_size__ = 
6072                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6073                            ;
6074                        }
6075                    }
6076                }
6077                Ok(HnswGraphFileInfo {
6078                    object_id: object_id__.unwrap_or_default(),
6079                    file_size: file_size__.unwrap_or_default(),
6080                })
6081            }
6082        }
6083        deserializer.deserialize_struct("hummock.HnswGraphFileInfo", FIELDS, GeneratedVisitor)
6084    }
6085}
6086impl serde::Serialize for HummockPinnedSnapshot {
6087    #[allow(deprecated)]
6088    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6089    where
6090        S: serde::Serializer,
6091    {
6092        use serde::ser::SerializeStruct;
6093        let mut len = 0;
6094        if self.context_id != 0 {
6095            len += 1;
6096        }
6097        if self.minimal_pinned_snapshot != 0 {
6098            len += 1;
6099        }
6100        let mut struct_ser = serializer.serialize_struct("hummock.HummockPinnedSnapshot", len)?;
6101        if self.context_id != 0 {
6102            struct_ser.serialize_field("contextId", &self.context_id)?;
6103        }
6104        if self.minimal_pinned_snapshot != 0 {
6105            #[allow(clippy::needless_borrow)]
6106            #[allow(clippy::needless_borrows_for_generic_args)]
6107            struct_ser.serialize_field("minimalPinnedSnapshot", ToString::to_string(&self.minimal_pinned_snapshot).as_str())?;
6108        }
6109        struct_ser.end()
6110    }
6111}
6112impl<'de> serde::Deserialize<'de> for HummockPinnedSnapshot {
6113    #[allow(deprecated)]
6114    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6115    where
6116        D: serde::Deserializer<'de>,
6117    {
6118        const FIELDS: &[&str] = &[
6119            "context_id",
6120            "contextId",
6121            "minimal_pinned_snapshot",
6122            "minimalPinnedSnapshot",
6123        ];
6124
6125        #[allow(clippy::enum_variant_names)]
6126        enum GeneratedField {
6127            ContextId,
6128            MinimalPinnedSnapshot,
6129        }
6130        impl<'de> serde::Deserialize<'de> for GeneratedField {
6131            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6132            where
6133                D: serde::Deserializer<'de>,
6134            {
6135                struct GeneratedVisitor;
6136
6137                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6138                    type Value = GeneratedField;
6139
6140                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6141                        write!(formatter, "expected one of: {:?}", &FIELDS)
6142                    }
6143
6144                    #[allow(unused_variables)]
6145                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6146                    where
6147                        E: serde::de::Error,
6148                    {
6149                        match value {
6150                            "contextId" | "context_id" => Ok(GeneratedField::ContextId),
6151                            "minimalPinnedSnapshot" | "minimal_pinned_snapshot" => Ok(GeneratedField::MinimalPinnedSnapshot),
6152                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6153                        }
6154                    }
6155                }
6156                deserializer.deserialize_identifier(GeneratedVisitor)
6157            }
6158        }
6159        struct GeneratedVisitor;
6160        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6161            type Value = HummockPinnedSnapshot;
6162
6163            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6164                formatter.write_str("struct hummock.HummockPinnedSnapshot")
6165            }
6166
6167            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockPinnedSnapshot, V::Error>
6168                where
6169                    V: serde::de::MapAccess<'de>,
6170            {
6171                let mut context_id__ = None;
6172                let mut minimal_pinned_snapshot__ = None;
6173                while let Some(k) = map_.next_key()? {
6174                    match k {
6175                        GeneratedField::ContextId => {
6176                            if context_id__.is_some() {
6177                                return Err(serde::de::Error::duplicate_field("contextId"));
6178                            }
6179                            context_id__ = 
6180                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6181                            ;
6182                        }
6183                        GeneratedField::MinimalPinnedSnapshot => {
6184                            if minimal_pinned_snapshot__.is_some() {
6185                                return Err(serde::de::Error::duplicate_field("minimalPinnedSnapshot"));
6186                            }
6187                            minimal_pinned_snapshot__ = 
6188                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6189                            ;
6190                        }
6191                    }
6192                }
6193                Ok(HummockPinnedSnapshot {
6194                    context_id: context_id__.unwrap_or_default(),
6195                    minimal_pinned_snapshot: minimal_pinned_snapshot__.unwrap_or_default(),
6196                })
6197            }
6198        }
6199        deserializer.deserialize_struct("hummock.HummockPinnedSnapshot", FIELDS, GeneratedVisitor)
6200    }
6201}
6202impl serde::Serialize for HummockPinnedVersion {
6203    #[allow(deprecated)]
6204    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6205    where
6206        S: serde::Serializer,
6207    {
6208        use serde::ser::SerializeStruct;
6209        let mut len = 0;
6210        if self.context_id != 0 {
6211            len += 1;
6212        }
6213        if self.min_pinned_id != 0 {
6214            len += 1;
6215        }
6216        let mut struct_ser = serializer.serialize_struct("hummock.HummockPinnedVersion", len)?;
6217        if self.context_id != 0 {
6218            struct_ser.serialize_field("contextId", &self.context_id)?;
6219        }
6220        if self.min_pinned_id != 0 {
6221            #[allow(clippy::needless_borrow)]
6222            #[allow(clippy::needless_borrows_for_generic_args)]
6223            struct_ser.serialize_field("minPinnedId", ToString::to_string(&self.min_pinned_id).as_str())?;
6224        }
6225        struct_ser.end()
6226    }
6227}
6228impl<'de> serde::Deserialize<'de> for HummockPinnedVersion {
6229    #[allow(deprecated)]
6230    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6231    where
6232        D: serde::Deserializer<'de>,
6233    {
6234        const FIELDS: &[&str] = &[
6235            "context_id",
6236            "contextId",
6237            "min_pinned_id",
6238            "minPinnedId",
6239        ];
6240
6241        #[allow(clippy::enum_variant_names)]
6242        enum GeneratedField {
6243            ContextId,
6244            MinPinnedId,
6245        }
6246        impl<'de> serde::Deserialize<'de> for GeneratedField {
6247            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6248            where
6249                D: serde::Deserializer<'de>,
6250            {
6251                struct GeneratedVisitor;
6252
6253                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6254                    type Value = GeneratedField;
6255
6256                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6257                        write!(formatter, "expected one of: {:?}", &FIELDS)
6258                    }
6259
6260                    #[allow(unused_variables)]
6261                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6262                    where
6263                        E: serde::de::Error,
6264                    {
6265                        match value {
6266                            "contextId" | "context_id" => Ok(GeneratedField::ContextId),
6267                            "minPinnedId" | "min_pinned_id" => Ok(GeneratedField::MinPinnedId),
6268                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6269                        }
6270                    }
6271                }
6272                deserializer.deserialize_identifier(GeneratedVisitor)
6273            }
6274        }
6275        struct GeneratedVisitor;
6276        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6277            type Value = HummockPinnedVersion;
6278
6279            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6280                formatter.write_str("struct hummock.HummockPinnedVersion")
6281            }
6282
6283            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockPinnedVersion, V::Error>
6284                where
6285                    V: serde::de::MapAccess<'de>,
6286            {
6287                let mut context_id__ = None;
6288                let mut min_pinned_id__ = None;
6289                while let Some(k) = map_.next_key()? {
6290                    match k {
6291                        GeneratedField::ContextId => {
6292                            if context_id__.is_some() {
6293                                return Err(serde::de::Error::duplicate_field("contextId"));
6294                            }
6295                            context_id__ = 
6296                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6297                            ;
6298                        }
6299                        GeneratedField::MinPinnedId => {
6300                            if min_pinned_id__.is_some() {
6301                                return Err(serde::de::Error::duplicate_field("minPinnedId"));
6302                            }
6303                            min_pinned_id__ = 
6304                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6305                            ;
6306                        }
6307                    }
6308                }
6309                Ok(HummockPinnedVersion {
6310                    context_id: context_id__.unwrap_or_default(),
6311                    min_pinned_id: min_pinned_id__.unwrap_or_default(),
6312                })
6313            }
6314        }
6315        deserializer.deserialize_struct("hummock.HummockPinnedVersion", FIELDS, GeneratedVisitor)
6316    }
6317}
6318impl serde::Serialize for HummockVersion {
6319    #[allow(deprecated)]
6320    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6321    where
6322        S: serde::Serializer,
6323    {
6324        use serde::ser::SerializeStruct;
6325        let mut len = 0;
6326        if self.id != 0 {
6327            len += 1;
6328        }
6329        if !self.levels.is_empty() {
6330            len += 1;
6331        }
6332        if self.max_committed_epoch != 0 {
6333            len += 1;
6334        }
6335        if !self.table_watermarks.is_empty() {
6336            len += 1;
6337        }
6338        if !self.table_change_logs.is_empty() {
6339            len += 1;
6340        }
6341        if !self.state_table_info.is_empty() {
6342            len += 1;
6343        }
6344        if !self.vector_indexes.is_empty() {
6345            len += 1;
6346        }
6347        let mut struct_ser = serializer.serialize_struct("hummock.HummockVersion", len)?;
6348        if self.id != 0 {
6349            #[allow(clippy::needless_borrow)]
6350            #[allow(clippy::needless_borrows_for_generic_args)]
6351            struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
6352        }
6353        if !self.levels.is_empty() {
6354            struct_ser.serialize_field("levels", &self.levels)?;
6355        }
6356        if self.max_committed_epoch != 0 {
6357            #[allow(clippy::needless_borrow)]
6358            #[allow(clippy::needless_borrows_for_generic_args)]
6359            struct_ser.serialize_field("maxCommittedEpoch", ToString::to_string(&self.max_committed_epoch).as_str())?;
6360        }
6361        if !self.table_watermarks.is_empty() {
6362            struct_ser.serialize_field("tableWatermarks", &self.table_watermarks)?;
6363        }
6364        if !self.table_change_logs.is_empty() {
6365            struct_ser.serialize_field("tableChangeLogs", &self.table_change_logs)?;
6366        }
6367        if !self.state_table_info.is_empty() {
6368            struct_ser.serialize_field("stateTableInfo", &self.state_table_info)?;
6369        }
6370        if !self.vector_indexes.is_empty() {
6371            struct_ser.serialize_field("vectorIndexes", &self.vector_indexes)?;
6372        }
6373        struct_ser.end()
6374    }
6375}
6376impl<'de> serde::Deserialize<'de> for HummockVersion {
6377    #[allow(deprecated)]
6378    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6379    where
6380        D: serde::Deserializer<'de>,
6381    {
6382        const FIELDS: &[&str] = &[
6383            "id",
6384            "levels",
6385            "max_committed_epoch",
6386            "maxCommittedEpoch",
6387            "table_watermarks",
6388            "tableWatermarks",
6389            "table_change_logs",
6390            "tableChangeLogs",
6391            "state_table_info",
6392            "stateTableInfo",
6393            "vector_indexes",
6394            "vectorIndexes",
6395        ];
6396
6397        #[allow(clippy::enum_variant_names)]
6398        enum GeneratedField {
6399            Id,
6400            Levels,
6401            MaxCommittedEpoch,
6402            TableWatermarks,
6403            TableChangeLogs,
6404            StateTableInfo,
6405            VectorIndexes,
6406        }
6407        impl<'de> serde::Deserialize<'de> for GeneratedField {
6408            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6409            where
6410                D: serde::Deserializer<'de>,
6411            {
6412                struct GeneratedVisitor;
6413
6414                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6415                    type Value = GeneratedField;
6416
6417                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6418                        write!(formatter, "expected one of: {:?}", &FIELDS)
6419                    }
6420
6421                    #[allow(unused_variables)]
6422                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6423                    where
6424                        E: serde::de::Error,
6425                    {
6426                        match value {
6427                            "id" => Ok(GeneratedField::Id),
6428                            "levels" => Ok(GeneratedField::Levels),
6429                            "maxCommittedEpoch" | "max_committed_epoch" => Ok(GeneratedField::MaxCommittedEpoch),
6430                            "tableWatermarks" | "table_watermarks" => Ok(GeneratedField::TableWatermarks),
6431                            "tableChangeLogs" | "table_change_logs" => Ok(GeneratedField::TableChangeLogs),
6432                            "stateTableInfo" | "state_table_info" => Ok(GeneratedField::StateTableInfo),
6433                            "vectorIndexes" | "vector_indexes" => Ok(GeneratedField::VectorIndexes),
6434                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6435                        }
6436                    }
6437                }
6438                deserializer.deserialize_identifier(GeneratedVisitor)
6439            }
6440        }
6441        struct GeneratedVisitor;
6442        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6443            type Value = HummockVersion;
6444
6445            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6446                formatter.write_str("struct hummock.HummockVersion")
6447            }
6448
6449            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersion, V::Error>
6450                where
6451                    V: serde::de::MapAccess<'de>,
6452            {
6453                let mut id__ = None;
6454                let mut levels__ = None;
6455                let mut max_committed_epoch__ = None;
6456                let mut table_watermarks__ = None;
6457                let mut table_change_logs__ = None;
6458                let mut state_table_info__ = None;
6459                let mut vector_indexes__ = None;
6460                while let Some(k) = map_.next_key()? {
6461                    match k {
6462                        GeneratedField::Id => {
6463                            if id__.is_some() {
6464                                return Err(serde::de::Error::duplicate_field("id"));
6465                            }
6466                            id__ = 
6467                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6468                            ;
6469                        }
6470                        GeneratedField::Levels => {
6471                            if levels__.is_some() {
6472                                return Err(serde::de::Error::duplicate_field("levels"));
6473                            }
6474                            levels__ = Some(
6475                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
6476                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
6477                            );
6478                        }
6479                        GeneratedField::MaxCommittedEpoch => {
6480                            if max_committed_epoch__.is_some() {
6481                                return Err(serde::de::Error::duplicate_field("maxCommittedEpoch"));
6482                            }
6483                            max_committed_epoch__ = 
6484                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6485                            ;
6486                        }
6487                        GeneratedField::TableWatermarks => {
6488                            if table_watermarks__.is_some() {
6489                                return Err(serde::de::Error::duplicate_field("tableWatermarks"));
6490                            }
6491                            table_watermarks__ = Some(
6492                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6493                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
6494                            );
6495                        }
6496                        GeneratedField::TableChangeLogs => {
6497                            if table_change_logs__.is_some() {
6498                                return Err(serde::de::Error::duplicate_field("tableChangeLogs"));
6499                            }
6500                            table_change_logs__ = Some(
6501                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6502                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
6503                            );
6504                        }
6505                        GeneratedField::StateTableInfo => {
6506                            if state_table_info__.is_some() {
6507                                return Err(serde::de::Error::duplicate_field("stateTableInfo"));
6508                            }
6509                            state_table_info__ = Some(
6510                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6511                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
6512                            );
6513                        }
6514                        GeneratedField::VectorIndexes => {
6515                            if vector_indexes__.is_some() {
6516                                return Err(serde::de::Error::duplicate_field("vectorIndexes"));
6517                            }
6518                            vector_indexes__ = Some(
6519                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6520                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
6521                            );
6522                        }
6523                    }
6524                }
6525                Ok(HummockVersion {
6526                    id: id__.unwrap_or_default(),
6527                    levels: levels__.unwrap_or_default(),
6528                    max_committed_epoch: max_committed_epoch__.unwrap_or_default(),
6529                    table_watermarks: table_watermarks__.unwrap_or_default(),
6530                    table_change_logs: table_change_logs__.unwrap_or_default(),
6531                    state_table_info: state_table_info__.unwrap_or_default(),
6532                    vector_indexes: vector_indexes__.unwrap_or_default(),
6533                })
6534            }
6535        }
6536        deserializer.deserialize_struct("hummock.HummockVersion", FIELDS, GeneratedVisitor)
6537    }
6538}
6539impl serde::Serialize for hummock_version::Levels {
6540    #[allow(deprecated)]
6541    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6542    where
6543        S: serde::Serializer,
6544    {
6545        use serde::ser::SerializeStruct;
6546        let mut len = 0;
6547        if !self.levels.is_empty() {
6548            len += 1;
6549        }
6550        if self.l0.is_some() {
6551            len += 1;
6552        }
6553        if self.group_id != 0 {
6554            len += 1;
6555        }
6556        if self.parent_group_id != 0 {
6557            len += 1;
6558        }
6559        if !self.member_table_ids.is_empty() {
6560            len += 1;
6561        }
6562        if self.compaction_group_version_id != 0 {
6563            len += 1;
6564        }
6565        let mut struct_ser = serializer.serialize_struct("hummock.HummockVersion.Levels", len)?;
6566        if !self.levels.is_empty() {
6567            struct_ser.serialize_field("levels", &self.levels)?;
6568        }
6569        if let Some(v) = self.l0.as_ref() {
6570            struct_ser.serialize_field("l0", v)?;
6571        }
6572        if self.group_id != 0 {
6573            #[allow(clippy::needless_borrow)]
6574            #[allow(clippy::needless_borrows_for_generic_args)]
6575            struct_ser.serialize_field("groupId", ToString::to_string(&self.group_id).as_str())?;
6576        }
6577        if self.parent_group_id != 0 {
6578            #[allow(clippy::needless_borrow)]
6579            #[allow(clippy::needless_borrows_for_generic_args)]
6580            struct_ser.serialize_field("parentGroupId", ToString::to_string(&self.parent_group_id).as_str())?;
6581        }
6582        if !self.member_table_ids.is_empty() {
6583            struct_ser.serialize_field("memberTableIds", &self.member_table_ids)?;
6584        }
6585        if self.compaction_group_version_id != 0 {
6586            #[allow(clippy::needless_borrow)]
6587            #[allow(clippy::needless_borrows_for_generic_args)]
6588            struct_ser.serialize_field("compactionGroupVersionId", ToString::to_string(&self.compaction_group_version_id).as_str())?;
6589        }
6590        struct_ser.end()
6591    }
6592}
6593impl<'de> serde::Deserialize<'de> for hummock_version::Levels {
6594    #[allow(deprecated)]
6595    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6596    where
6597        D: serde::Deserializer<'de>,
6598    {
6599        const FIELDS: &[&str] = &[
6600            "levels",
6601            "l0",
6602            "group_id",
6603            "groupId",
6604            "parent_group_id",
6605            "parentGroupId",
6606            "member_table_ids",
6607            "memberTableIds",
6608            "compaction_group_version_id",
6609            "compactionGroupVersionId",
6610        ];
6611
6612        #[allow(clippy::enum_variant_names)]
6613        enum GeneratedField {
6614            Levels,
6615            L0,
6616            GroupId,
6617            ParentGroupId,
6618            MemberTableIds,
6619            CompactionGroupVersionId,
6620        }
6621        impl<'de> serde::Deserialize<'de> for GeneratedField {
6622            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6623            where
6624                D: serde::Deserializer<'de>,
6625            {
6626                struct GeneratedVisitor;
6627
6628                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6629                    type Value = GeneratedField;
6630
6631                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6632                        write!(formatter, "expected one of: {:?}", &FIELDS)
6633                    }
6634
6635                    #[allow(unused_variables)]
6636                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6637                    where
6638                        E: serde::de::Error,
6639                    {
6640                        match value {
6641                            "levels" => Ok(GeneratedField::Levels),
6642                            "l0" => Ok(GeneratedField::L0),
6643                            "groupId" | "group_id" => Ok(GeneratedField::GroupId),
6644                            "parentGroupId" | "parent_group_id" => Ok(GeneratedField::ParentGroupId),
6645                            "memberTableIds" | "member_table_ids" => Ok(GeneratedField::MemberTableIds),
6646                            "compactionGroupVersionId" | "compaction_group_version_id" => Ok(GeneratedField::CompactionGroupVersionId),
6647                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6648                        }
6649                    }
6650                }
6651                deserializer.deserialize_identifier(GeneratedVisitor)
6652            }
6653        }
6654        struct GeneratedVisitor;
6655        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6656            type Value = hummock_version::Levels;
6657
6658            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6659                formatter.write_str("struct hummock.HummockVersion.Levels")
6660            }
6661
6662            fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version::Levels, V::Error>
6663                where
6664                    V: serde::de::MapAccess<'de>,
6665            {
6666                let mut levels__ = None;
6667                let mut l0__ = None;
6668                let mut group_id__ = None;
6669                let mut parent_group_id__ = None;
6670                let mut member_table_ids__ = None;
6671                let mut compaction_group_version_id__ = None;
6672                while let Some(k) = map_.next_key()? {
6673                    match k {
6674                        GeneratedField::Levels => {
6675                            if levels__.is_some() {
6676                                return Err(serde::de::Error::duplicate_field("levels"));
6677                            }
6678                            levels__ = Some(map_.next_value()?);
6679                        }
6680                        GeneratedField::L0 => {
6681                            if l0__.is_some() {
6682                                return Err(serde::de::Error::duplicate_field("l0"));
6683                            }
6684                            l0__ = map_.next_value()?;
6685                        }
6686                        GeneratedField::GroupId => {
6687                            if group_id__.is_some() {
6688                                return Err(serde::de::Error::duplicate_field("groupId"));
6689                            }
6690                            group_id__ = 
6691                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6692                            ;
6693                        }
6694                        GeneratedField::ParentGroupId => {
6695                            if parent_group_id__.is_some() {
6696                                return Err(serde::de::Error::duplicate_field("parentGroupId"));
6697                            }
6698                            parent_group_id__ = 
6699                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6700                            ;
6701                        }
6702                        GeneratedField::MemberTableIds => {
6703                            if member_table_ids__.is_some() {
6704                                return Err(serde::de::Error::duplicate_field("memberTableIds"));
6705                            }
6706                            member_table_ids__ = 
6707                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6708                                    .into_iter().map(|x| x.0).collect())
6709                            ;
6710                        }
6711                        GeneratedField::CompactionGroupVersionId => {
6712                            if compaction_group_version_id__.is_some() {
6713                                return Err(serde::de::Error::duplicate_field("compactionGroupVersionId"));
6714                            }
6715                            compaction_group_version_id__ = 
6716                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6717                            ;
6718                        }
6719                    }
6720                }
6721                Ok(hummock_version::Levels {
6722                    levels: levels__.unwrap_or_default(),
6723                    l0: l0__,
6724                    group_id: group_id__.unwrap_or_default(),
6725                    parent_group_id: parent_group_id__.unwrap_or_default(),
6726                    member_table_ids: member_table_ids__.unwrap_or_default(),
6727                    compaction_group_version_id: compaction_group_version_id__.unwrap_or_default(),
6728                })
6729            }
6730        }
6731        deserializer.deserialize_struct("hummock.HummockVersion.Levels", FIELDS, GeneratedVisitor)
6732    }
6733}
6734impl serde::Serialize for HummockVersionArchive {
6735    #[allow(deprecated)]
6736    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6737    where
6738        S: serde::Serializer,
6739    {
6740        use serde::ser::SerializeStruct;
6741        let mut len = 0;
6742        if self.version.is_some() {
6743            len += 1;
6744        }
6745        if !self.version_deltas.is_empty() {
6746            len += 1;
6747        }
6748        let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionArchive", len)?;
6749        if let Some(v) = self.version.as_ref() {
6750            struct_ser.serialize_field("version", v)?;
6751        }
6752        if !self.version_deltas.is_empty() {
6753            struct_ser.serialize_field("versionDeltas", &self.version_deltas)?;
6754        }
6755        struct_ser.end()
6756    }
6757}
6758impl<'de> serde::Deserialize<'de> for HummockVersionArchive {
6759    #[allow(deprecated)]
6760    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6761    where
6762        D: serde::Deserializer<'de>,
6763    {
6764        const FIELDS: &[&str] = &[
6765            "version",
6766            "version_deltas",
6767            "versionDeltas",
6768        ];
6769
6770        #[allow(clippy::enum_variant_names)]
6771        enum GeneratedField {
6772            Version,
6773            VersionDeltas,
6774        }
6775        impl<'de> serde::Deserialize<'de> for GeneratedField {
6776            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6777            where
6778                D: serde::Deserializer<'de>,
6779            {
6780                struct GeneratedVisitor;
6781
6782                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6783                    type Value = GeneratedField;
6784
6785                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6786                        write!(formatter, "expected one of: {:?}", &FIELDS)
6787                    }
6788
6789                    #[allow(unused_variables)]
6790                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6791                    where
6792                        E: serde::de::Error,
6793                    {
6794                        match value {
6795                            "version" => Ok(GeneratedField::Version),
6796                            "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
6797                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6798                        }
6799                    }
6800                }
6801                deserializer.deserialize_identifier(GeneratedVisitor)
6802            }
6803        }
6804        struct GeneratedVisitor;
6805        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6806            type Value = HummockVersionArchive;
6807
6808            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6809                formatter.write_str("struct hummock.HummockVersionArchive")
6810            }
6811
6812            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionArchive, V::Error>
6813                where
6814                    V: serde::de::MapAccess<'de>,
6815            {
6816                let mut version__ = None;
6817                let mut version_deltas__ = None;
6818                while let Some(k) = map_.next_key()? {
6819                    match k {
6820                        GeneratedField::Version => {
6821                            if version__.is_some() {
6822                                return Err(serde::de::Error::duplicate_field("version"));
6823                            }
6824                            version__ = map_.next_value()?;
6825                        }
6826                        GeneratedField::VersionDeltas => {
6827                            if version_deltas__.is_some() {
6828                                return Err(serde::de::Error::duplicate_field("versionDeltas"));
6829                            }
6830                            version_deltas__ = Some(map_.next_value()?);
6831                        }
6832                    }
6833                }
6834                Ok(HummockVersionArchive {
6835                    version: version__,
6836                    version_deltas: version_deltas__.unwrap_or_default(),
6837                })
6838            }
6839        }
6840        deserializer.deserialize_struct("hummock.HummockVersionArchive", FIELDS, GeneratedVisitor)
6841    }
6842}
6843impl serde::Serialize for HummockVersionCheckpoint {
6844    #[allow(deprecated)]
6845    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6846    where
6847        S: serde::Serializer,
6848    {
6849        use serde::ser::SerializeStruct;
6850        let mut len = 0;
6851        if self.version.is_some() {
6852            len += 1;
6853        }
6854        if !self.stale_objects.is_empty() {
6855            len += 1;
6856        }
6857        let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionCheckpoint", len)?;
6858        if let Some(v) = self.version.as_ref() {
6859            struct_ser.serialize_field("version", v)?;
6860        }
6861        if !self.stale_objects.is_empty() {
6862            struct_ser.serialize_field("staleObjects", &self.stale_objects)?;
6863        }
6864        struct_ser.end()
6865    }
6866}
6867impl<'de> serde::Deserialize<'de> for HummockVersionCheckpoint {
6868    #[allow(deprecated)]
6869    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6870    where
6871        D: serde::Deserializer<'de>,
6872    {
6873        const FIELDS: &[&str] = &[
6874            "version",
6875            "stale_objects",
6876            "staleObjects",
6877        ];
6878
6879        #[allow(clippy::enum_variant_names)]
6880        enum GeneratedField {
6881            Version,
6882            StaleObjects,
6883        }
6884        impl<'de> serde::Deserialize<'de> for GeneratedField {
6885            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6886            where
6887                D: serde::Deserializer<'de>,
6888            {
6889                struct GeneratedVisitor;
6890
6891                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6892                    type Value = GeneratedField;
6893
6894                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6895                        write!(formatter, "expected one of: {:?}", &FIELDS)
6896                    }
6897
6898                    #[allow(unused_variables)]
6899                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6900                    where
6901                        E: serde::de::Error,
6902                    {
6903                        match value {
6904                            "version" => Ok(GeneratedField::Version),
6905                            "staleObjects" | "stale_objects" => Ok(GeneratedField::StaleObjects),
6906                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6907                        }
6908                    }
6909                }
6910                deserializer.deserialize_identifier(GeneratedVisitor)
6911            }
6912        }
6913        struct GeneratedVisitor;
6914        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6915            type Value = HummockVersionCheckpoint;
6916
6917            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6918                formatter.write_str("struct hummock.HummockVersionCheckpoint")
6919            }
6920
6921            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionCheckpoint, V::Error>
6922                where
6923                    V: serde::de::MapAccess<'de>,
6924            {
6925                let mut version__ = None;
6926                let mut stale_objects__ = None;
6927                while let Some(k) = map_.next_key()? {
6928                    match k {
6929                        GeneratedField::Version => {
6930                            if version__.is_some() {
6931                                return Err(serde::de::Error::duplicate_field("version"));
6932                            }
6933                            version__ = map_.next_value()?;
6934                        }
6935                        GeneratedField::StaleObjects => {
6936                            if stale_objects__.is_some() {
6937                                return Err(serde::de::Error::duplicate_field("staleObjects"));
6938                            }
6939                            stale_objects__ = Some(
6940                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
6941                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
6942                            );
6943                        }
6944                    }
6945                }
6946                Ok(HummockVersionCheckpoint {
6947                    version: version__,
6948                    stale_objects: stale_objects__.unwrap_or_default(),
6949                })
6950            }
6951        }
6952        deserializer.deserialize_struct("hummock.HummockVersionCheckpoint", FIELDS, GeneratedVisitor)
6953    }
6954}
6955impl serde::Serialize for hummock_version_checkpoint::StaleObjects {
6956    #[allow(deprecated)]
6957    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6958    where
6959        S: serde::Serializer,
6960    {
6961        use serde::ser::SerializeStruct;
6962        let mut len = 0;
6963        if !self.id.is_empty() {
6964            len += 1;
6965        }
6966        if self.total_file_size != 0 {
6967            len += 1;
6968        }
6969        if !self.vector_files.is_empty() {
6970            len += 1;
6971        }
6972        let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionCheckpoint.StaleObjects", len)?;
6973        if !self.id.is_empty() {
6974            struct_ser.serialize_field("id", &self.id.iter().map(ToString::to_string).collect::<Vec<_>>())?;
6975        }
6976        if self.total_file_size != 0 {
6977            #[allow(clippy::needless_borrow)]
6978            #[allow(clippy::needless_borrows_for_generic_args)]
6979            struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
6980        }
6981        if !self.vector_files.is_empty() {
6982            struct_ser.serialize_field("vectorFiles", &self.vector_files)?;
6983        }
6984        struct_ser.end()
6985    }
6986}
6987impl<'de> serde::Deserialize<'de> for hummock_version_checkpoint::StaleObjects {
6988    #[allow(deprecated)]
6989    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6990    where
6991        D: serde::Deserializer<'de>,
6992    {
6993        const FIELDS: &[&str] = &[
6994            "id",
6995            "total_file_size",
6996            "totalFileSize",
6997            "vector_files",
6998            "vectorFiles",
6999        ];
7000
7001        #[allow(clippy::enum_variant_names)]
7002        enum GeneratedField {
7003            Id,
7004            TotalFileSize,
7005            VectorFiles,
7006        }
7007        impl<'de> serde::Deserialize<'de> for GeneratedField {
7008            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7009            where
7010                D: serde::Deserializer<'de>,
7011            {
7012                struct GeneratedVisitor;
7013
7014                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7015                    type Value = GeneratedField;
7016
7017                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7018                        write!(formatter, "expected one of: {:?}", &FIELDS)
7019                    }
7020
7021                    #[allow(unused_variables)]
7022                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7023                    where
7024                        E: serde::de::Error,
7025                    {
7026                        match value {
7027                            "id" => Ok(GeneratedField::Id),
7028                            "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
7029                            "vectorFiles" | "vector_files" => Ok(GeneratedField::VectorFiles),
7030                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7031                        }
7032                    }
7033                }
7034                deserializer.deserialize_identifier(GeneratedVisitor)
7035            }
7036        }
7037        struct GeneratedVisitor;
7038        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7039            type Value = hummock_version_checkpoint::StaleObjects;
7040
7041            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7042                formatter.write_str("struct hummock.HummockVersionCheckpoint.StaleObjects")
7043            }
7044
7045            fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version_checkpoint::StaleObjects, V::Error>
7046                where
7047                    V: serde::de::MapAccess<'de>,
7048            {
7049                let mut id__ = None;
7050                let mut total_file_size__ = None;
7051                let mut vector_files__ = None;
7052                while let Some(k) = map_.next_key()? {
7053                    match k {
7054                        GeneratedField::Id => {
7055                            if id__.is_some() {
7056                                return Err(serde::de::Error::duplicate_field("id"));
7057                            }
7058                            id__ = 
7059                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7060                                    .into_iter().map(|x| x.0).collect())
7061                            ;
7062                        }
7063                        GeneratedField::TotalFileSize => {
7064                            if total_file_size__.is_some() {
7065                                return Err(serde::de::Error::duplicate_field("totalFileSize"));
7066                            }
7067                            total_file_size__ = 
7068                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7069                            ;
7070                        }
7071                        GeneratedField::VectorFiles => {
7072                            if vector_files__.is_some() {
7073                                return Err(serde::de::Error::duplicate_field("vectorFiles"));
7074                            }
7075                            vector_files__ = Some(map_.next_value()?);
7076                        }
7077                    }
7078                }
7079                Ok(hummock_version_checkpoint::StaleObjects {
7080                    id: id__.unwrap_or_default(),
7081                    total_file_size: total_file_size__.unwrap_or_default(),
7082                    vector_files: vector_files__.unwrap_or_default(),
7083                })
7084            }
7085        }
7086        deserializer.deserialize_struct("hummock.HummockVersionCheckpoint.StaleObjects", FIELDS, GeneratedVisitor)
7087    }
7088}
7089impl serde::Serialize for HummockVersionDelta {
7090    #[allow(deprecated)]
7091    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7092    where
7093        S: serde::Serializer,
7094    {
7095        use serde::ser::SerializeStruct;
7096        let mut len = 0;
7097        if self.id != 0 {
7098            len += 1;
7099        }
7100        if self.prev_id != 0 {
7101            len += 1;
7102        }
7103        if !self.group_deltas.is_empty() {
7104            len += 1;
7105        }
7106        if self.max_committed_epoch != 0 {
7107            len += 1;
7108        }
7109        if self.trivial_move {
7110            len += 1;
7111        }
7112        if !self.new_table_watermarks.is_empty() {
7113            len += 1;
7114        }
7115        if !self.removed_table_ids.is_empty() {
7116            len += 1;
7117        }
7118        if !self.change_log_delta.is_empty() {
7119            len += 1;
7120        }
7121        if !self.state_table_info_delta.is_empty() {
7122            len += 1;
7123        }
7124        if !self.vector_index_delta.is_empty() {
7125            len += 1;
7126        }
7127        let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDelta", len)?;
7128        if self.id != 0 {
7129            #[allow(clippy::needless_borrow)]
7130            #[allow(clippy::needless_borrows_for_generic_args)]
7131            struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
7132        }
7133        if self.prev_id != 0 {
7134            #[allow(clippy::needless_borrow)]
7135            #[allow(clippy::needless_borrows_for_generic_args)]
7136            struct_ser.serialize_field("prevId", ToString::to_string(&self.prev_id).as_str())?;
7137        }
7138        if !self.group_deltas.is_empty() {
7139            struct_ser.serialize_field("groupDeltas", &self.group_deltas)?;
7140        }
7141        if self.max_committed_epoch != 0 {
7142            #[allow(clippy::needless_borrow)]
7143            #[allow(clippy::needless_borrows_for_generic_args)]
7144            struct_ser.serialize_field("maxCommittedEpoch", ToString::to_string(&self.max_committed_epoch).as_str())?;
7145        }
7146        if self.trivial_move {
7147            struct_ser.serialize_field("trivialMove", &self.trivial_move)?;
7148        }
7149        if !self.new_table_watermarks.is_empty() {
7150            struct_ser.serialize_field("newTableWatermarks", &self.new_table_watermarks)?;
7151        }
7152        if !self.removed_table_ids.is_empty() {
7153            struct_ser.serialize_field("removedTableIds", &self.removed_table_ids)?;
7154        }
7155        if !self.change_log_delta.is_empty() {
7156            struct_ser.serialize_field("changeLogDelta", &self.change_log_delta)?;
7157        }
7158        if !self.state_table_info_delta.is_empty() {
7159            struct_ser.serialize_field("stateTableInfoDelta", &self.state_table_info_delta)?;
7160        }
7161        if !self.vector_index_delta.is_empty() {
7162            struct_ser.serialize_field("vectorIndexDelta", &self.vector_index_delta)?;
7163        }
7164        struct_ser.end()
7165    }
7166}
7167impl<'de> serde::Deserialize<'de> for HummockVersionDelta {
7168    #[allow(deprecated)]
7169    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7170    where
7171        D: serde::Deserializer<'de>,
7172    {
7173        const FIELDS: &[&str] = &[
7174            "id",
7175            "prev_id",
7176            "prevId",
7177            "group_deltas",
7178            "groupDeltas",
7179            "max_committed_epoch",
7180            "maxCommittedEpoch",
7181            "trivial_move",
7182            "trivialMove",
7183            "new_table_watermarks",
7184            "newTableWatermarks",
7185            "removed_table_ids",
7186            "removedTableIds",
7187            "change_log_delta",
7188            "changeLogDelta",
7189            "state_table_info_delta",
7190            "stateTableInfoDelta",
7191            "vector_index_delta",
7192            "vectorIndexDelta",
7193        ];
7194
7195        #[allow(clippy::enum_variant_names)]
7196        enum GeneratedField {
7197            Id,
7198            PrevId,
7199            GroupDeltas,
7200            MaxCommittedEpoch,
7201            TrivialMove,
7202            NewTableWatermarks,
7203            RemovedTableIds,
7204            ChangeLogDelta,
7205            StateTableInfoDelta,
7206            VectorIndexDelta,
7207        }
7208        impl<'de> serde::Deserialize<'de> for GeneratedField {
7209            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7210            where
7211                D: serde::Deserializer<'de>,
7212            {
7213                struct GeneratedVisitor;
7214
7215                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7216                    type Value = GeneratedField;
7217
7218                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7219                        write!(formatter, "expected one of: {:?}", &FIELDS)
7220                    }
7221
7222                    #[allow(unused_variables)]
7223                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7224                    where
7225                        E: serde::de::Error,
7226                    {
7227                        match value {
7228                            "id" => Ok(GeneratedField::Id),
7229                            "prevId" | "prev_id" => Ok(GeneratedField::PrevId),
7230                            "groupDeltas" | "group_deltas" => Ok(GeneratedField::GroupDeltas),
7231                            "maxCommittedEpoch" | "max_committed_epoch" => Ok(GeneratedField::MaxCommittedEpoch),
7232                            "trivialMove" | "trivial_move" => Ok(GeneratedField::TrivialMove),
7233                            "newTableWatermarks" | "new_table_watermarks" => Ok(GeneratedField::NewTableWatermarks),
7234                            "removedTableIds" | "removed_table_ids" => Ok(GeneratedField::RemovedTableIds),
7235                            "changeLogDelta" | "change_log_delta" => Ok(GeneratedField::ChangeLogDelta),
7236                            "stateTableInfoDelta" | "state_table_info_delta" => Ok(GeneratedField::StateTableInfoDelta),
7237                            "vectorIndexDelta" | "vector_index_delta" => Ok(GeneratedField::VectorIndexDelta),
7238                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7239                        }
7240                    }
7241                }
7242                deserializer.deserialize_identifier(GeneratedVisitor)
7243            }
7244        }
7245        struct GeneratedVisitor;
7246        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7247            type Value = HummockVersionDelta;
7248
7249            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7250                formatter.write_str("struct hummock.HummockVersionDelta")
7251            }
7252
7253            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionDelta, V::Error>
7254                where
7255                    V: serde::de::MapAccess<'de>,
7256            {
7257                let mut id__ = None;
7258                let mut prev_id__ = None;
7259                let mut group_deltas__ = None;
7260                let mut max_committed_epoch__ = None;
7261                let mut trivial_move__ = None;
7262                let mut new_table_watermarks__ = None;
7263                let mut removed_table_ids__ = None;
7264                let mut change_log_delta__ = None;
7265                let mut state_table_info_delta__ = None;
7266                let mut vector_index_delta__ = None;
7267                while let Some(k) = map_.next_key()? {
7268                    match k {
7269                        GeneratedField::Id => {
7270                            if id__.is_some() {
7271                                return Err(serde::de::Error::duplicate_field("id"));
7272                            }
7273                            id__ = 
7274                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7275                            ;
7276                        }
7277                        GeneratedField::PrevId => {
7278                            if prev_id__.is_some() {
7279                                return Err(serde::de::Error::duplicate_field("prevId"));
7280                            }
7281                            prev_id__ = 
7282                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7283                            ;
7284                        }
7285                        GeneratedField::GroupDeltas => {
7286                            if group_deltas__.is_some() {
7287                                return Err(serde::de::Error::duplicate_field("groupDeltas"));
7288                            }
7289                            group_deltas__ = Some(
7290                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
7291                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
7292                            );
7293                        }
7294                        GeneratedField::MaxCommittedEpoch => {
7295                            if max_committed_epoch__.is_some() {
7296                                return Err(serde::de::Error::duplicate_field("maxCommittedEpoch"));
7297                            }
7298                            max_committed_epoch__ = 
7299                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7300                            ;
7301                        }
7302                        GeneratedField::TrivialMove => {
7303                            if trivial_move__.is_some() {
7304                                return Err(serde::de::Error::duplicate_field("trivialMove"));
7305                            }
7306                            trivial_move__ = Some(map_.next_value()?);
7307                        }
7308                        GeneratedField::NewTableWatermarks => {
7309                            if new_table_watermarks__.is_some() {
7310                                return Err(serde::de::Error::duplicate_field("newTableWatermarks"));
7311                            }
7312                            new_table_watermarks__ = Some(
7313                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
7314                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
7315                            );
7316                        }
7317                        GeneratedField::RemovedTableIds => {
7318                            if removed_table_ids__.is_some() {
7319                                return Err(serde::de::Error::duplicate_field("removedTableIds"));
7320                            }
7321                            removed_table_ids__ = 
7322                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7323                                    .into_iter().map(|x| x.0).collect())
7324                            ;
7325                        }
7326                        GeneratedField::ChangeLogDelta => {
7327                            if change_log_delta__.is_some() {
7328                                return Err(serde::de::Error::duplicate_field("changeLogDelta"));
7329                            }
7330                            change_log_delta__ = Some(
7331                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
7332                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
7333                            );
7334                        }
7335                        GeneratedField::StateTableInfoDelta => {
7336                            if state_table_info_delta__.is_some() {
7337                                return Err(serde::de::Error::duplicate_field("stateTableInfoDelta"));
7338                            }
7339                            state_table_info_delta__ = Some(
7340                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
7341                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
7342                            );
7343                        }
7344                        GeneratedField::VectorIndexDelta => {
7345                            if vector_index_delta__.is_some() {
7346                                return Err(serde::de::Error::duplicate_field("vectorIndexDelta"));
7347                            }
7348                            vector_index_delta__ = Some(
7349                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
7350                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
7351                            );
7352                        }
7353                    }
7354                }
7355                Ok(HummockVersionDelta {
7356                    id: id__.unwrap_or_default(),
7357                    prev_id: prev_id__.unwrap_or_default(),
7358                    group_deltas: group_deltas__.unwrap_or_default(),
7359                    max_committed_epoch: max_committed_epoch__.unwrap_or_default(),
7360                    trivial_move: trivial_move__.unwrap_or_default(),
7361                    new_table_watermarks: new_table_watermarks__.unwrap_or_default(),
7362                    removed_table_ids: removed_table_ids__.unwrap_or_default(),
7363                    change_log_delta: change_log_delta__.unwrap_or_default(),
7364                    state_table_info_delta: state_table_info_delta__.unwrap_or_default(),
7365                    vector_index_delta: vector_index_delta__.unwrap_or_default(),
7366                })
7367            }
7368        }
7369        deserializer.deserialize_struct("hummock.HummockVersionDelta", FIELDS, GeneratedVisitor)
7370    }
7371}
7372impl serde::Serialize for hummock_version_delta::ChangeLogDelta {
7373    #[allow(deprecated)]
7374    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7375    where
7376        S: serde::Serializer,
7377    {
7378        use serde::ser::SerializeStruct;
7379        let mut len = 0;
7380        if self.new_log.is_some() {
7381            len += 1;
7382        }
7383        if self.truncate_epoch != 0 {
7384            len += 1;
7385        }
7386        let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDelta.ChangeLogDelta", len)?;
7387        if let Some(v) = self.new_log.as_ref() {
7388            struct_ser.serialize_field("newLog", v)?;
7389        }
7390        if self.truncate_epoch != 0 {
7391            #[allow(clippy::needless_borrow)]
7392            #[allow(clippy::needless_borrows_for_generic_args)]
7393            struct_ser.serialize_field("truncateEpoch", ToString::to_string(&self.truncate_epoch).as_str())?;
7394        }
7395        struct_ser.end()
7396    }
7397}
7398impl<'de> serde::Deserialize<'de> for hummock_version_delta::ChangeLogDelta {
7399    #[allow(deprecated)]
7400    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7401    where
7402        D: serde::Deserializer<'de>,
7403    {
7404        const FIELDS: &[&str] = &[
7405            "new_log",
7406            "newLog",
7407            "truncate_epoch",
7408            "truncateEpoch",
7409        ];
7410
7411        #[allow(clippy::enum_variant_names)]
7412        enum GeneratedField {
7413            NewLog,
7414            TruncateEpoch,
7415        }
7416        impl<'de> serde::Deserialize<'de> for GeneratedField {
7417            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7418            where
7419                D: serde::Deserializer<'de>,
7420            {
7421                struct GeneratedVisitor;
7422
7423                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7424                    type Value = GeneratedField;
7425
7426                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7427                        write!(formatter, "expected one of: {:?}", &FIELDS)
7428                    }
7429
7430                    #[allow(unused_variables)]
7431                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7432                    where
7433                        E: serde::de::Error,
7434                    {
7435                        match value {
7436                            "newLog" | "new_log" => Ok(GeneratedField::NewLog),
7437                            "truncateEpoch" | "truncate_epoch" => Ok(GeneratedField::TruncateEpoch),
7438                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7439                        }
7440                    }
7441                }
7442                deserializer.deserialize_identifier(GeneratedVisitor)
7443            }
7444        }
7445        struct GeneratedVisitor;
7446        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7447            type Value = hummock_version_delta::ChangeLogDelta;
7448
7449            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7450                formatter.write_str("struct hummock.HummockVersionDelta.ChangeLogDelta")
7451            }
7452
7453            fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version_delta::ChangeLogDelta, V::Error>
7454                where
7455                    V: serde::de::MapAccess<'de>,
7456            {
7457                let mut new_log__ = None;
7458                let mut truncate_epoch__ = None;
7459                while let Some(k) = map_.next_key()? {
7460                    match k {
7461                        GeneratedField::NewLog => {
7462                            if new_log__.is_some() {
7463                                return Err(serde::de::Error::duplicate_field("newLog"));
7464                            }
7465                            new_log__ = map_.next_value()?;
7466                        }
7467                        GeneratedField::TruncateEpoch => {
7468                            if truncate_epoch__.is_some() {
7469                                return Err(serde::de::Error::duplicate_field("truncateEpoch"));
7470                            }
7471                            truncate_epoch__ = 
7472                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7473                            ;
7474                        }
7475                    }
7476                }
7477                Ok(hummock_version_delta::ChangeLogDelta {
7478                    new_log: new_log__,
7479                    truncate_epoch: truncate_epoch__.unwrap_or_default(),
7480                })
7481            }
7482        }
7483        deserializer.deserialize_struct("hummock.HummockVersionDelta.ChangeLogDelta", FIELDS, GeneratedVisitor)
7484    }
7485}
7486impl serde::Serialize for hummock_version_delta::GroupDeltas {
7487    #[allow(deprecated)]
7488    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7489    where
7490        S: serde::Serializer,
7491    {
7492        use serde::ser::SerializeStruct;
7493        let mut len = 0;
7494        if !self.group_deltas.is_empty() {
7495            len += 1;
7496        }
7497        let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDelta.GroupDeltas", len)?;
7498        if !self.group_deltas.is_empty() {
7499            struct_ser.serialize_field("groupDeltas", &self.group_deltas)?;
7500        }
7501        struct_ser.end()
7502    }
7503}
7504impl<'de> serde::Deserialize<'de> for hummock_version_delta::GroupDeltas {
7505    #[allow(deprecated)]
7506    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7507    where
7508        D: serde::Deserializer<'de>,
7509    {
7510        const FIELDS: &[&str] = &[
7511            "group_deltas",
7512            "groupDeltas",
7513        ];
7514
7515        #[allow(clippy::enum_variant_names)]
7516        enum GeneratedField {
7517            GroupDeltas,
7518        }
7519        impl<'de> serde::Deserialize<'de> for GeneratedField {
7520            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7521            where
7522                D: serde::Deserializer<'de>,
7523            {
7524                struct GeneratedVisitor;
7525
7526                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7527                    type Value = GeneratedField;
7528
7529                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7530                        write!(formatter, "expected one of: {:?}", &FIELDS)
7531                    }
7532
7533                    #[allow(unused_variables)]
7534                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7535                    where
7536                        E: serde::de::Error,
7537                    {
7538                        match value {
7539                            "groupDeltas" | "group_deltas" => Ok(GeneratedField::GroupDeltas),
7540                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7541                        }
7542                    }
7543                }
7544                deserializer.deserialize_identifier(GeneratedVisitor)
7545            }
7546        }
7547        struct GeneratedVisitor;
7548        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7549            type Value = hummock_version_delta::GroupDeltas;
7550
7551            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7552                formatter.write_str("struct hummock.HummockVersionDelta.GroupDeltas")
7553            }
7554
7555            fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version_delta::GroupDeltas, V::Error>
7556                where
7557                    V: serde::de::MapAccess<'de>,
7558            {
7559                let mut group_deltas__ = None;
7560                while let Some(k) = map_.next_key()? {
7561                    match k {
7562                        GeneratedField::GroupDeltas => {
7563                            if group_deltas__.is_some() {
7564                                return Err(serde::de::Error::duplicate_field("groupDeltas"));
7565                            }
7566                            group_deltas__ = Some(map_.next_value()?);
7567                        }
7568                    }
7569                }
7570                Ok(hummock_version_delta::GroupDeltas {
7571                    group_deltas: group_deltas__.unwrap_or_default(),
7572                })
7573            }
7574        }
7575        deserializer.deserialize_struct("hummock.HummockVersionDelta.GroupDeltas", FIELDS, GeneratedVisitor)
7576    }
7577}
7578impl serde::Serialize for HummockVersionDeltas {
7579    #[allow(deprecated)]
7580    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7581    where
7582        S: serde::Serializer,
7583    {
7584        use serde::ser::SerializeStruct;
7585        let mut len = 0;
7586        if !self.version_deltas.is_empty() {
7587            len += 1;
7588        }
7589        let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDeltas", len)?;
7590        if !self.version_deltas.is_empty() {
7591            struct_ser.serialize_field("versionDeltas", &self.version_deltas)?;
7592        }
7593        struct_ser.end()
7594    }
7595}
7596impl<'de> serde::Deserialize<'de> for HummockVersionDeltas {
7597    #[allow(deprecated)]
7598    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7599    where
7600        D: serde::Deserializer<'de>,
7601    {
7602        const FIELDS: &[&str] = &[
7603            "version_deltas",
7604            "versionDeltas",
7605        ];
7606
7607        #[allow(clippy::enum_variant_names)]
7608        enum GeneratedField {
7609            VersionDeltas,
7610        }
7611        impl<'de> serde::Deserialize<'de> for GeneratedField {
7612            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7613            where
7614                D: serde::Deserializer<'de>,
7615            {
7616                struct GeneratedVisitor;
7617
7618                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7619                    type Value = GeneratedField;
7620
7621                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7622                        write!(formatter, "expected one of: {:?}", &FIELDS)
7623                    }
7624
7625                    #[allow(unused_variables)]
7626                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7627                    where
7628                        E: serde::de::Error,
7629                    {
7630                        match value {
7631                            "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
7632                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7633                        }
7634                    }
7635                }
7636                deserializer.deserialize_identifier(GeneratedVisitor)
7637            }
7638        }
7639        struct GeneratedVisitor;
7640        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7641            type Value = HummockVersionDeltas;
7642
7643            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7644                formatter.write_str("struct hummock.HummockVersionDeltas")
7645            }
7646
7647            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionDeltas, V::Error>
7648                where
7649                    V: serde::de::MapAccess<'de>,
7650            {
7651                let mut version_deltas__ = None;
7652                while let Some(k) = map_.next_key()? {
7653                    match k {
7654                        GeneratedField::VersionDeltas => {
7655                            if version_deltas__.is_some() {
7656                                return Err(serde::de::Error::duplicate_field("versionDeltas"));
7657                            }
7658                            version_deltas__ = Some(map_.next_value()?);
7659                        }
7660                    }
7661                }
7662                Ok(HummockVersionDeltas {
7663                    version_deltas: version_deltas__.unwrap_or_default(),
7664                })
7665            }
7666        }
7667        deserializer.deserialize_struct("hummock.HummockVersionDeltas", FIELDS, GeneratedVisitor)
7668    }
7669}
7670impl serde::Serialize for HummockVersionStats {
7671    #[allow(deprecated)]
7672    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7673    where
7674        S: serde::Serializer,
7675    {
7676        use serde::ser::SerializeStruct;
7677        let mut len = 0;
7678        if self.hummock_version_id != 0 {
7679            len += 1;
7680        }
7681        if !self.table_stats.is_empty() {
7682            len += 1;
7683        }
7684        let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionStats", len)?;
7685        if self.hummock_version_id != 0 {
7686            #[allow(clippy::needless_borrow)]
7687            #[allow(clippy::needless_borrows_for_generic_args)]
7688            struct_ser.serialize_field("hummockVersionId", ToString::to_string(&self.hummock_version_id).as_str())?;
7689        }
7690        if !self.table_stats.is_empty() {
7691            struct_ser.serialize_field("tableStats", &self.table_stats)?;
7692        }
7693        struct_ser.end()
7694    }
7695}
7696impl<'de> serde::Deserialize<'de> for HummockVersionStats {
7697    #[allow(deprecated)]
7698    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7699    where
7700        D: serde::Deserializer<'de>,
7701    {
7702        const FIELDS: &[&str] = &[
7703            "hummock_version_id",
7704            "hummockVersionId",
7705            "table_stats",
7706            "tableStats",
7707        ];
7708
7709        #[allow(clippy::enum_variant_names)]
7710        enum GeneratedField {
7711            HummockVersionId,
7712            TableStats,
7713        }
7714        impl<'de> serde::Deserialize<'de> for GeneratedField {
7715            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7716            where
7717                D: serde::Deserializer<'de>,
7718            {
7719                struct GeneratedVisitor;
7720
7721                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7722                    type Value = GeneratedField;
7723
7724                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7725                        write!(formatter, "expected one of: {:?}", &FIELDS)
7726                    }
7727
7728                    #[allow(unused_variables)]
7729                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7730                    where
7731                        E: serde::de::Error,
7732                    {
7733                        match value {
7734                            "hummockVersionId" | "hummock_version_id" => Ok(GeneratedField::HummockVersionId),
7735                            "tableStats" | "table_stats" => Ok(GeneratedField::TableStats),
7736                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7737                        }
7738                    }
7739                }
7740                deserializer.deserialize_identifier(GeneratedVisitor)
7741            }
7742        }
7743        struct GeneratedVisitor;
7744        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7745            type Value = HummockVersionStats;
7746
7747            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7748                formatter.write_str("struct hummock.HummockVersionStats")
7749            }
7750
7751            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionStats, V::Error>
7752                where
7753                    V: serde::de::MapAccess<'de>,
7754            {
7755                let mut hummock_version_id__ = None;
7756                let mut table_stats__ = None;
7757                while let Some(k) = map_.next_key()? {
7758                    match k {
7759                        GeneratedField::HummockVersionId => {
7760                            if hummock_version_id__.is_some() {
7761                                return Err(serde::de::Error::duplicate_field("hummockVersionId"));
7762                            }
7763                            hummock_version_id__ = 
7764                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7765                            ;
7766                        }
7767                        GeneratedField::TableStats => {
7768                            if table_stats__.is_some() {
7769                                return Err(serde::de::Error::duplicate_field("tableStats"));
7770                            }
7771                            table_stats__ = Some(
7772                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
7773                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
7774                            );
7775                        }
7776                    }
7777                }
7778                Ok(HummockVersionStats {
7779                    hummock_version_id: hummock_version_id__.unwrap_or_default(),
7780                    table_stats: table_stats__.unwrap_or_default(),
7781                })
7782            }
7783        }
7784        deserializer.deserialize_struct("hummock.HummockVersionStats", FIELDS, GeneratedVisitor)
7785    }
7786}
7787impl serde::Serialize for InitMetadataForReplayRequest {
7788    #[allow(deprecated)]
7789    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7790    where
7791        S: serde::Serializer,
7792    {
7793        use serde::ser::SerializeStruct;
7794        let mut len = 0;
7795        if !self.tables.is_empty() {
7796            len += 1;
7797        }
7798        if !self.compaction_groups.is_empty() {
7799            len += 1;
7800        }
7801        let mut struct_ser = serializer.serialize_struct("hummock.InitMetadataForReplayRequest", len)?;
7802        if !self.tables.is_empty() {
7803            struct_ser.serialize_field("tables", &self.tables)?;
7804        }
7805        if !self.compaction_groups.is_empty() {
7806            struct_ser.serialize_field("compactionGroups", &self.compaction_groups)?;
7807        }
7808        struct_ser.end()
7809    }
7810}
7811impl<'de> serde::Deserialize<'de> for InitMetadataForReplayRequest {
7812    #[allow(deprecated)]
7813    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7814    where
7815        D: serde::Deserializer<'de>,
7816    {
7817        const FIELDS: &[&str] = &[
7818            "tables",
7819            "compaction_groups",
7820            "compactionGroups",
7821        ];
7822
7823        #[allow(clippy::enum_variant_names)]
7824        enum GeneratedField {
7825            Tables,
7826            CompactionGroups,
7827        }
7828        impl<'de> serde::Deserialize<'de> for GeneratedField {
7829            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7830            where
7831                D: serde::Deserializer<'de>,
7832            {
7833                struct GeneratedVisitor;
7834
7835                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7836                    type Value = GeneratedField;
7837
7838                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7839                        write!(formatter, "expected one of: {:?}", &FIELDS)
7840                    }
7841
7842                    #[allow(unused_variables)]
7843                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7844                    where
7845                        E: serde::de::Error,
7846                    {
7847                        match value {
7848                            "tables" => Ok(GeneratedField::Tables),
7849                            "compactionGroups" | "compaction_groups" => Ok(GeneratedField::CompactionGroups),
7850                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7851                        }
7852                    }
7853                }
7854                deserializer.deserialize_identifier(GeneratedVisitor)
7855            }
7856        }
7857        struct GeneratedVisitor;
7858        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7859            type Value = InitMetadataForReplayRequest;
7860
7861            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7862                formatter.write_str("struct hummock.InitMetadataForReplayRequest")
7863            }
7864
7865            fn visit_map<V>(self, mut map_: V) -> std::result::Result<InitMetadataForReplayRequest, V::Error>
7866                where
7867                    V: serde::de::MapAccess<'de>,
7868            {
7869                let mut tables__ = None;
7870                let mut compaction_groups__ = None;
7871                while let Some(k) = map_.next_key()? {
7872                    match k {
7873                        GeneratedField::Tables => {
7874                            if tables__.is_some() {
7875                                return Err(serde::de::Error::duplicate_field("tables"));
7876                            }
7877                            tables__ = Some(map_.next_value()?);
7878                        }
7879                        GeneratedField::CompactionGroups => {
7880                            if compaction_groups__.is_some() {
7881                                return Err(serde::de::Error::duplicate_field("compactionGroups"));
7882                            }
7883                            compaction_groups__ = Some(map_.next_value()?);
7884                        }
7885                    }
7886                }
7887                Ok(InitMetadataForReplayRequest {
7888                    tables: tables__.unwrap_or_default(),
7889                    compaction_groups: compaction_groups__.unwrap_or_default(),
7890                })
7891            }
7892        }
7893        deserializer.deserialize_struct("hummock.InitMetadataForReplayRequest", FIELDS, GeneratedVisitor)
7894    }
7895}
7896impl serde::Serialize for InitMetadataForReplayResponse {
7897    #[allow(deprecated)]
7898    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7899    where
7900        S: serde::Serializer,
7901    {
7902        use serde::ser::SerializeStruct;
7903        let len = 0;
7904        let struct_ser = serializer.serialize_struct("hummock.InitMetadataForReplayResponse", len)?;
7905        struct_ser.end()
7906    }
7907}
7908impl<'de> serde::Deserialize<'de> for InitMetadataForReplayResponse {
7909    #[allow(deprecated)]
7910    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7911    where
7912        D: serde::Deserializer<'de>,
7913    {
7914        const FIELDS: &[&str] = &[
7915        ];
7916
7917        #[allow(clippy::enum_variant_names)]
7918        enum GeneratedField {
7919        }
7920        impl<'de> serde::Deserialize<'de> for GeneratedField {
7921            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7922            where
7923                D: serde::Deserializer<'de>,
7924            {
7925                struct GeneratedVisitor;
7926
7927                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7928                    type Value = GeneratedField;
7929
7930                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7931                        write!(formatter, "expected one of: {:?}", &FIELDS)
7932                    }
7933
7934                    #[allow(unused_variables)]
7935                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7936                    where
7937                        E: serde::de::Error,
7938                    {
7939                            Err(serde::de::Error::unknown_field(value, FIELDS))
7940                    }
7941                }
7942                deserializer.deserialize_identifier(GeneratedVisitor)
7943            }
7944        }
7945        struct GeneratedVisitor;
7946        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7947            type Value = InitMetadataForReplayResponse;
7948
7949            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7950                formatter.write_str("struct hummock.InitMetadataForReplayResponse")
7951            }
7952
7953            fn visit_map<V>(self, mut map_: V) -> std::result::Result<InitMetadataForReplayResponse, V::Error>
7954                where
7955                    V: serde::de::MapAccess<'de>,
7956            {
7957                while map_.next_key::<GeneratedField>()?.is_some() {
7958                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7959                }
7960                Ok(InitMetadataForReplayResponse {
7961                })
7962            }
7963        }
7964        deserializer.deserialize_struct("hummock.InitMetadataForReplayResponse", FIELDS, GeneratedVisitor)
7965    }
7966}
7967impl serde::Serialize for InputLevel {
7968    #[allow(deprecated)]
7969    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7970    where
7971        S: serde::Serializer,
7972    {
7973        use serde::ser::SerializeStruct;
7974        let mut len = 0;
7975        if self.level_idx != 0 {
7976            len += 1;
7977        }
7978        if self.level_type != 0 {
7979            len += 1;
7980        }
7981        if !self.table_infos.is_empty() {
7982            len += 1;
7983        }
7984        let mut struct_ser = serializer.serialize_struct("hummock.InputLevel", len)?;
7985        if self.level_idx != 0 {
7986            struct_ser.serialize_field("levelIdx", &self.level_idx)?;
7987        }
7988        if self.level_type != 0 {
7989            let v = LevelType::try_from(self.level_type)
7990                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.level_type)))?;
7991            struct_ser.serialize_field("levelType", &v)?;
7992        }
7993        if !self.table_infos.is_empty() {
7994            struct_ser.serialize_field("tableInfos", &self.table_infos)?;
7995        }
7996        struct_ser.end()
7997    }
7998}
7999impl<'de> serde::Deserialize<'de> for InputLevel {
8000    #[allow(deprecated)]
8001    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8002    where
8003        D: serde::Deserializer<'de>,
8004    {
8005        const FIELDS: &[&str] = &[
8006            "level_idx",
8007            "levelIdx",
8008            "level_type",
8009            "levelType",
8010            "table_infos",
8011            "tableInfos",
8012        ];
8013
8014        #[allow(clippy::enum_variant_names)]
8015        enum GeneratedField {
8016            LevelIdx,
8017            LevelType,
8018            TableInfos,
8019        }
8020        impl<'de> serde::Deserialize<'de> for GeneratedField {
8021            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8022            where
8023                D: serde::Deserializer<'de>,
8024            {
8025                struct GeneratedVisitor;
8026
8027                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8028                    type Value = GeneratedField;
8029
8030                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8031                        write!(formatter, "expected one of: {:?}", &FIELDS)
8032                    }
8033
8034                    #[allow(unused_variables)]
8035                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8036                    where
8037                        E: serde::de::Error,
8038                    {
8039                        match value {
8040                            "levelIdx" | "level_idx" => Ok(GeneratedField::LevelIdx),
8041                            "levelType" | "level_type" => Ok(GeneratedField::LevelType),
8042                            "tableInfos" | "table_infos" => Ok(GeneratedField::TableInfos),
8043                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8044                        }
8045                    }
8046                }
8047                deserializer.deserialize_identifier(GeneratedVisitor)
8048            }
8049        }
8050        struct GeneratedVisitor;
8051        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8052            type Value = InputLevel;
8053
8054            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8055                formatter.write_str("struct hummock.InputLevel")
8056            }
8057
8058            fn visit_map<V>(self, mut map_: V) -> std::result::Result<InputLevel, V::Error>
8059                where
8060                    V: serde::de::MapAccess<'de>,
8061            {
8062                let mut level_idx__ = None;
8063                let mut level_type__ = None;
8064                let mut table_infos__ = None;
8065                while let Some(k) = map_.next_key()? {
8066                    match k {
8067                        GeneratedField::LevelIdx => {
8068                            if level_idx__.is_some() {
8069                                return Err(serde::de::Error::duplicate_field("levelIdx"));
8070                            }
8071                            level_idx__ = 
8072                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8073                            ;
8074                        }
8075                        GeneratedField::LevelType => {
8076                            if level_type__.is_some() {
8077                                return Err(serde::de::Error::duplicate_field("levelType"));
8078                            }
8079                            level_type__ = Some(map_.next_value::<LevelType>()? as i32);
8080                        }
8081                        GeneratedField::TableInfos => {
8082                            if table_infos__.is_some() {
8083                                return Err(serde::de::Error::duplicate_field("tableInfos"));
8084                            }
8085                            table_infos__ = Some(map_.next_value()?);
8086                        }
8087                    }
8088                }
8089                Ok(InputLevel {
8090                    level_idx: level_idx__.unwrap_or_default(),
8091                    level_type: level_type__.unwrap_or_default(),
8092                    table_infos: table_infos__.unwrap_or_default(),
8093                })
8094            }
8095        }
8096        deserializer.deserialize_struct("hummock.InputLevel", FIELDS, GeneratedVisitor)
8097    }
8098}
8099impl serde::Serialize for IntraLevelDelta {
8100    #[allow(deprecated)]
8101    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8102    where
8103        S: serde::Serializer,
8104    {
8105        use serde::ser::SerializeStruct;
8106        let mut len = 0;
8107        if self.level_idx != 0 {
8108            len += 1;
8109        }
8110        if self.l0_sub_level_id != 0 {
8111            len += 1;
8112        }
8113        if !self.removed_table_ids.is_empty() {
8114            len += 1;
8115        }
8116        if !self.inserted_table_infos.is_empty() {
8117            len += 1;
8118        }
8119        if self.vnode_partition_count != 0 {
8120            len += 1;
8121        }
8122        if self.compaction_group_version_id != 0 {
8123            len += 1;
8124        }
8125        let mut struct_ser = serializer.serialize_struct("hummock.IntraLevelDelta", len)?;
8126        if self.level_idx != 0 {
8127            struct_ser.serialize_field("levelIdx", &self.level_idx)?;
8128        }
8129        if self.l0_sub_level_id != 0 {
8130            #[allow(clippy::needless_borrow)]
8131            #[allow(clippy::needless_borrows_for_generic_args)]
8132            struct_ser.serialize_field("l0SubLevelId", ToString::to_string(&self.l0_sub_level_id).as_str())?;
8133        }
8134        if !self.removed_table_ids.is_empty() {
8135            struct_ser.serialize_field("removedTableIds", &self.removed_table_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
8136        }
8137        if !self.inserted_table_infos.is_empty() {
8138            struct_ser.serialize_field("insertedTableInfos", &self.inserted_table_infos)?;
8139        }
8140        if self.vnode_partition_count != 0 {
8141            struct_ser.serialize_field("vnodePartitionCount", &self.vnode_partition_count)?;
8142        }
8143        if self.compaction_group_version_id != 0 {
8144            #[allow(clippy::needless_borrow)]
8145            #[allow(clippy::needless_borrows_for_generic_args)]
8146            struct_ser.serialize_field("compactionGroupVersionId", ToString::to_string(&self.compaction_group_version_id).as_str())?;
8147        }
8148        struct_ser.end()
8149    }
8150}
8151impl<'de> serde::Deserialize<'de> for IntraLevelDelta {
8152    #[allow(deprecated)]
8153    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8154    where
8155        D: serde::Deserializer<'de>,
8156    {
8157        const FIELDS: &[&str] = &[
8158            "level_idx",
8159            "levelIdx",
8160            "l0_sub_level_id",
8161            "l0SubLevelId",
8162            "removed_table_ids",
8163            "removedTableIds",
8164            "inserted_table_infos",
8165            "insertedTableInfos",
8166            "vnode_partition_count",
8167            "vnodePartitionCount",
8168            "compaction_group_version_id",
8169            "compactionGroupVersionId",
8170        ];
8171
8172        #[allow(clippy::enum_variant_names)]
8173        enum GeneratedField {
8174            LevelIdx,
8175            L0SubLevelId,
8176            RemovedTableIds,
8177            InsertedTableInfos,
8178            VnodePartitionCount,
8179            CompactionGroupVersionId,
8180        }
8181        impl<'de> serde::Deserialize<'de> for GeneratedField {
8182            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8183            where
8184                D: serde::Deserializer<'de>,
8185            {
8186                struct GeneratedVisitor;
8187
8188                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8189                    type Value = GeneratedField;
8190
8191                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8192                        write!(formatter, "expected one of: {:?}", &FIELDS)
8193                    }
8194
8195                    #[allow(unused_variables)]
8196                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8197                    where
8198                        E: serde::de::Error,
8199                    {
8200                        match value {
8201                            "levelIdx" | "level_idx" => Ok(GeneratedField::LevelIdx),
8202                            "l0SubLevelId" | "l0_sub_level_id" => Ok(GeneratedField::L0SubLevelId),
8203                            "removedTableIds" | "removed_table_ids" => Ok(GeneratedField::RemovedTableIds),
8204                            "insertedTableInfos" | "inserted_table_infos" => Ok(GeneratedField::InsertedTableInfos),
8205                            "vnodePartitionCount" | "vnode_partition_count" => Ok(GeneratedField::VnodePartitionCount),
8206                            "compactionGroupVersionId" | "compaction_group_version_id" => Ok(GeneratedField::CompactionGroupVersionId),
8207                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8208                        }
8209                    }
8210                }
8211                deserializer.deserialize_identifier(GeneratedVisitor)
8212            }
8213        }
8214        struct GeneratedVisitor;
8215        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8216            type Value = IntraLevelDelta;
8217
8218            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8219                formatter.write_str("struct hummock.IntraLevelDelta")
8220            }
8221
8222            fn visit_map<V>(self, mut map_: V) -> std::result::Result<IntraLevelDelta, V::Error>
8223                where
8224                    V: serde::de::MapAccess<'de>,
8225            {
8226                let mut level_idx__ = None;
8227                let mut l0_sub_level_id__ = None;
8228                let mut removed_table_ids__ = None;
8229                let mut inserted_table_infos__ = None;
8230                let mut vnode_partition_count__ = None;
8231                let mut compaction_group_version_id__ = None;
8232                while let Some(k) = map_.next_key()? {
8233                    match k {
8234                        GeneratedField::LevelIdx => {
8235                            if level_idx__.is_some() {
8236                                return Err(serde::de::Error::duplicate_field("levelIdx"));
8237                            }
8238                            level_idx__ = 
8239                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8240                            ;
8241                        }
8242                        GeneratedField::L0SubLevelId => {
8243                            if l0_sub_level_id__.is_some() {
8244                                return Err(serde::de::Error::duplicate_field("l0SubLevelId"));
8245                            }
8246                            l0_sub_level_id__ = 
8247                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8248                            ;
8249                        }
8250                        GeneratedField::RemovedTableIds => {
8251                            if removed_table_ids__.is_some() {
8252                                return Err(serde::de::Error::duplicate_field("removedTableIds"));
8253                            }
8254                            removed_table_ids__ = 
8255                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8256                                    .into_iter().map(|x| x.0).collect())
8257                            ;
8258                        }
8259                        GeneratedField::InsertedTableInfos => {
8260                            if inserted_table_infos__.is_some() {
8261                                return Err(serde::de::Error::duplicate_field("insertedTableInfos"));
8262                            }
8263                            inserted_table_infos__ = Some(map_.next_value()?);
8264                        }
8265                        GeneratedField::VnodePartitionCount => {
8266                            if vnode_partition_count__.is_some() {
8267                                return Err(serde::de::Error::duplicate_field("vnodePartitionCount"));
8268                            }
8269                            vnode_partition_count__ = 
8270                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8271                            ;
8272                        }
8273                        GeneratedField::CompactionGroupVersionId => {
8274                            if compaction_group_version_id__.is_some() {
8275                                return Err(serde::de::Error::duplicate_field("compactionGroupVersionId"));
8276                            }
8277                            compaction_group_version_id__ = 
8278                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8279                            ;
8280                        }
8281                    }
8282                }
8283                Ok(IntraLevelDelta {
8284                    level_idx: level_idx__.unwrap_or_default(),
8285                    l0_sub_level_id: l0_sub_level_id__.unwrap_or_default(),
8286                    removed_table_ids: removed_table_ids__.unwrap_or_default(),
8287                    inserted_table_infos: inserted_table_infos__.unwrap_or_default(),
8288                    vnode_partition_count: vnode_partition_count__.unwrap_or_default(),
8289                    compaction_group_version_id: compaction_group_version_id__.unwrap_or_default(),
8290                })
8291            }
8292        }
8293        deserializer.deserialize_struct("hummock.IntraLevelDelta", FIELDS, GeneratedVisitor)
8294    }
8295}
8296impl serde::Serialize for KeyRange {
8297    #[allow(deprecated)]
8298    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8299    where
8300        S: serde::Serializer,
8301    {
8302        use serde::ser::SerializeStruct;
8303        let mut len = 0;
8304        if !self.left.is_empty() {
8305            len += 1;
8306        }
8307        if !self.right.is_empty() {
8308            len += 1;
8309        }
8310        if self.right_exclusive {
8311            len += 1;
8312        }
8313        let mut struct_ser = serializer.serialize_struct("hummock.KeyRange", len)?;
8314        if !self.left.is_empty() {
8315            #[allow(clippy::needless_borrow)]
8316            #[allow(clippy::needless_borrows_for_generic_args)]
8317            struct_ser.serialize_field("left", pbjson::private::base64::encode(&self.left).as_str())?;
8318        }
8319        if !self.right.is_empty() {
8320            #[allow(clippy::needless_borrow)]
8321            #[allow(clippy::needless_borrows_for_generic_args)]
8322            struct_ser.serialize_field("right", pbjson::private::base64::encode(&self.right).as_str())?;
8323        }
8324        if self.right_exclusive {
8325            struct_ser.serialize_field("rightExclusive", &self.right_exclusive)?;
8326        }
8327        struct_ser.end()
8328    }
8329}
8330impl<'de> serde::Deserialize<'de> for KeyRange {
8331    #[allow(deprecated)]
8332    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8333    where
8334        D: serde::Deserializer<'de>,
8335    {
8336        const FIELDS: &[&str] = &[
8337            "left",
8338            "right",
8339            "right_exclusive",
8340            "rightExclusive",
8341        ];
8342
8343        #[allow(clippy::enum_variant_names)]
8344        enum GeneratedField {
8345            Left,
8346            Right,
8347            RightExclusive,
8348        }
8349        impl<'de> serde::Deserialize<'de> for GeneratedField {
8350            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8351            where
8352                D: serde::Deserializer<'de>,
8353            {
8354                struct GeneratedVisitor;
8355
8356                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8357                    type Value = GeneratedField;
8358
8359                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8360                        write!(formatter, "expected one of: {:?}", &FIELDS)
8361                    }
8362
8363                    #[allow(unused_variables)]
8364                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8365                    where
8366                        E: serde::de::Error,
8367                    {
8368                        match value {
8369                            "left" => Ok(GeneratedField::Left),
8370                            "right" => Ok(GeneratedField::Right),
8371                            "rightExclusive" | "right_exclusive" => Ok(GeneratedField::RightExclusive),
8372                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8373                        }
8374                    }
8375                }
8376                deserializer.deserialize_identifier(GeneratedVisitor)
8377            }
8378        }
8379        struct GeneratedVisitor;
8380        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8381            type Value = KeyRange;
8382
8383            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8384                formatter.write_str("struct hummock.KeyRange")
8385            }
8386
8387            fn visit_map<V>(self, mut map_: V) -> std::result::Result<KeyRange, V::Error>
8388                where
8389                    V: serde::de::MapAccess<'de>,
8390            {
8391                let mut left__ = None;
8392                let mut right__ = None;
8393                let mut right_exclusive__ = None;
8394                while let Some(k) = map_.next_key()? {
8395                    match k {
8396                        GeneratedField::Left => {
8397                            if left__.is_some() {
8398                                return Err(serde::de::Error::duplicate_field("left"));
8399                            }
8400                            left__ = 
8401                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
8402                            ;
8403                        }
8404                        GeneratedField::Right => {
8405                            if right__.is_some() {
8406                                return Err(serde::de::Error::duplicate_field("right"));
8407                            }
8408                            right__ = 
8409                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
8410                            ;
8411                        }
8412                        GeneratedField::RightExclusive => {
8413                            if right_exclusive__.is_some() {
8414                                return Err(serde::de::Error::duplicate_field("rightExclusive"));
8415                            }
8416                            right_exclusive__ = Some(map_.next_value()?);
8417                        }
8418                    }
8419                }
8420                Ok(KeyRange {
8421                    left: left__.unwrap_or_default(),
8422                    right: right__.unwrap_or_default(),
8423                    right_exclusive: right_exclusive__.unwrap_or_default(),
8424                })
8425            }
8426        }
8427        deserializer.deserialize_struct("hummock.KeyRange", FIELDS, GeneratedVisitor)
8428    }
8429}
8430impl serde::Serialize for Level {
8431    #[allow(deprecated)]
8432    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8433    where
8434        S: serde::Serializer,
8435    {
8436        use serde::ser::SerializeStruct;
8437        let mut len = 0;
8438        if self.level_idx != 0 {
8439            len += 1;
8440        }
8441        if self.level_type != 0 {
8442            len += 1;
8443        }
8444        if !self.table_infos.is_empty() {
8445            len += 1;
8446        }
8447        if self.total_file_size != 0 {
8448            len += 1;
8449        }
8450        if self.sub_level_id != 0 {
8451            len += 1;
8452        }
8453        if self.uncompressed_file_size != 0 {
8454            len += 1;
8455        }
8456        if self.vnode_partition_count != 0 {
8457            len += 1;
8458        }
8459        let mut struct_ser = serializer.serialize_struct("hummock.Level", len)?;
8460        if self.level_idx != 0 {
8461            struct_ser.serialize_field("levelIdx", &self.level_idx)?;
8462        }
8463        if self.level_type != 0 {
8464            let v = LevelType::try_from(self.level_type)
8465                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.level_type)))?;
8466            struct_ser.serialize_field("levelType", &v)?;
8467        }
8468        if !self.table_infos.is_empty() {
8469            struct_ser.serialize_field("tableInfos", &self.table_infos)?;
8470        }
8471        if self.total_file_size != 0 {
8472            #[allow(clippy::needless_borrow)]
8473            #[allow(clippy::needless_borrows_for_generic_args)]
8474            struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
8475        }
8476        if self.sub_level_id != 0 {
8477            #[allow(clippy::needless_borrow)]
8478            #[allow(clippy::needless_borrows_for_generic_args)]
8479            struct_ser.serialize_field("subLevelId", ToString::to_string(&self.sub_level_id).as_str())?;
8480        }
8481        if self.uncompressed_file_size != 0 {
8482            #[allow(clippy::needless_borrow)]
8483            #[allow(clippy::needless_borrows_for_generic_args)]
8484            struct_ser.serialize_field("uncompressedFileSize", ToString::to_string(&self.uncompressed_file_size).as_str())?;
8485        }
8486        if self.vnode_partition_count != 0 {
8487            struct_ser.serialize_field("vnodePartitionCount", &self.vnode_partition_count)?;
8488        }
8489        struct_ser.end()
8490    }
8491}
8492impl<'de> serde::Deserialize<'de> for Level {
8493    #[allow(deprecated)]
8494    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8495    where
8496        D: serde::Deserializer<'de>,
8497    {
8498        const FIELDS: &[&str] = &[
8499            "level_idx",
8500            "levelIdx",
8501            "level_type",
8502            "levelType",
8503            "table_infos",
8504            "tableInfos",
8505            "total_file_size",
8506            "totalFileSize",
8507            "sub_level_id",
8508            "subLevelId",
8509            "uncompressed_file_size",
8510            "uncompressedFileSize",
8511            "vnode_partition_count",
8512            "vnodePartitionCount",
8513        ];
8514
8515        #[allow(clippy::enum_variant_names)]
8516        enum GeneratedField {
8517            LevelIdx,
8518            LevelType,
8519            TableInfos,
8520            TotalFileSize,
8521            SubLevelId,
8522            UncompressedFileSize,
8523            VnodePartitionCount,
8524        }
8525        impl<'de> serde::Deserialize<'de> for GeneratedField {
8526            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8527            where
8528                D: serde::Deserializer<'de>,
8529            {
8530                struct GeneratedVisitor;
8531
8532                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8533                    type Value = GeneratedField;
8534
8535                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8536                        write!(formatter, "expected one of: {:?}", &FIELDS)
8537                    }
8538
8539                    #[allow(unused_variables)]
8540                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8541                    where
8542                        E: serde::de::Error,
8543                    {
8544                        match value {
8545                            "levelIdx" | "level_idx" => Ok(GeneratedField::LevelIdx),
8546                            "levelType" | "level_type" => Ok(GeneratedField::LevelType),
8547                            "tableInfos" | "table_infos" => Ok(GeneratedField::TableInfos),
8548                            "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
8549                            "subLevelId" | "sub_level_id" => Ok(GeneratedField::SubLevelId),
8550                            "uncompressedFileSize" | "uncompressed_file_size" => Ok(GeneratedField::UncompressedFileSize),
8551                            "vnodePartitionCount" | "vnode_partition_count" => Ok(GeneratedField::VnodePartitionCount),
8552                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8553                        }
8554                    }
8555                }
8556                deserializer.deserialize_identifier(GeneratedVisitor)
8557            }
8558        }
8559        struct GeneratedVisitor;
8560        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8561            type Value = Level;
8562
8563            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8564                formatter.write_str("struct hummock.Level")
8565            }
8566
8567            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Level, V::Error>
8568                where
8569                    V: serde::de::MapAccess<'de>,
8570            {
8571                let mut level_idx__ = None;
8572                let mut level_type__ = None;
8573                let mut table_infos__ = None;
8574                let mut total_file_size__ = None;
8575                let mut sub_level_id__ = None;
8576                let mut uncompressed_file_size__ = None;
8577                let mut vnode_partition_count__ = None;
8578                while let Some(k) = map_.next_key()? {
8579                    match k {
8580                        GeneratedField::LevelIdx => {
8581                            if level_idx__.is_some() {
8582                                return Err(serde::de::Error::duplicate_field("levelIdx"));
8583                            }
8584                            level_idx__ = 
8585                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8586                            ;
8587                        }
8588                        GeneratedField::LevelType => {
8589                            if level_type__.is_some() {
8590                                return Err(serde::de::Error::duplicate_field("levelType"));
8591                            }
8592                            level_type__ = Some(map_.next_value::<LevelType>()? as i32);
8593                        }
8594                        GeneratedField::TableInfos => {
8595                            if table_infos__.is_some() {
8596                                return Err(serde::de::Error::duplicate_field("tableInfos"));
8597                            }
8598                            table_infos__ = Some(map_.next_value()?);
8599                        }
8600                        GeneratedField::TotalFileSize => {
8601                            if total_file_size__.is_some() {
8602                                return Err(serde::de::Error::duplicate_field("totalFileSize"));
8603                            }
8604                            total_file_size__ = 
8605                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8606                            ;
8607                        }
8608                        GeneratedField::SubLevelId => {
8609                            if sub_level_id__.is_some() {
8610                                return Err(serde::de::Error::duplicate_field("subLevelId"));
8611                            }
8612                            sub_level_id__ = 
8613                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8614                            ;
8615                        }
8616                        GeneratedField::UncompressedFileSize => {
8617                            if uncompressed_file_size__.is_some() {
8618                                return Err(serde::de::Error::duplicate_field("uncompressedFileSize"));
8619                            }
8620                            uncompressed_file_size__ = 
8621                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8622                            ;
8623                        }
8624                        GeneratedField::VnodePartitionCount => {
8625                            if vnode_partition_count__.is_some() {
8626                                return Err(serde::de::Error::duplicate_field("vnodePartitionCount"));
8627                            }
8628                            vnode_partition_count__ = 
8629                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8630                            ;
8631                        }
8632                    }
8633                }
8634                Ok(Level {
8635                    level_idx: level_idx__.unwrap_or_default(),
8636                    level_type: level_type__.unwrap_or_default(),
8637                    table_infos: table_infos__.unwrap_or_default(),
8638                    total_file_size: total_file_size__.unwrap_or_default(),
8639                    sub_level_id: sub_level_id__.unwrap_or_default(),
8640                    uncompressed_file_size: uncompressed_file_size__.unwrap_or_default(),
8641                    vnode_partition_count: vnode_partition_count__.unwrap_or_default(),
8642                })
8643            }
8644        }
8645        deserializer.deserialize_struct("hummock.Level", FIELDS, GeneratedVisitor)
8646    }
8647}
8648impl serde::Serialize for LevelHandler {
8649    #[allow(deprecated)]
8650    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8651    where
8652        S: serde::Serializer,
8653    {
8654        use serde::ser::SerializeStruct;
8655        let mut len = 0;
8656        if self.level != 0 {
8657            len += 1;
8658        }
8659        if !self.tasks.is_empty() {
8660            len += 1;
8661        }
8662        let mut struct_ser = serializer.serialize_struct("hummock.LevelHandler", len)?;
8663        if self.level != 0 {
8664            struct_ser.serialize_field("level", &self.level)?;
8665        }
8666        if !self.tasks.is_empty() {
8667            struct_ser.serialize_field("tasks", &self.tasks)?;
8668        }
8669        struct_ser.end()
8670    }
8671}
8672impl<'de> serde::Deserialize<'de> for LevelHandler {
8673    #[allow(deprecated)]
8674    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8675    where
8676        D: serde::Deserializer<'de>,
8677    {
8678        const FIELDS: &[&str] = &[
8679            "level",
8680            "tasks",
8681        ];
8682
8683        #[allow(clippy::enum_variant_names)]
8684        enum GeneratedField {
8685            Level,
8686            Tasks,
8687        }
8688        impl<'de> serde::Deserialize<'de> for GeneratedField {
8689            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8690            where
8691                D: serde::Deserializer<'de>,
8692            {
8693                struct GeneratedVisitor;
8694
8695                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8696                    type Value = GeneratedField;
8697
8698                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8699                        write!(formatter, "expected one of: {:?}", &FIELDS)
8700                    }
8701
8702                    #[allow(unused_variables)]
8703                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8704                    where
8705                        E: serde::de::Error,
8706                    {
8707                        match value {
8708                            "level" => Ok(GeneratedField::Level),
8709                            "tasks" => Ok(GeneratedField::Tasks),
8710                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8711                        }
8712                    }
8713                }
8714                deserializer.deserialize_identifier(GeneratedVisitor)
8715            }
8716        }
8717        struct GeneratedVisitor;
8718        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8719            type Value = LevelHandler;
8720
8721            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8722                formatter.write_str("struct hummock.LevelHandler")
8723            }
8724
8725            fn visit_map<V>(self, mut map_: V) -> std::result::Result<LevelHandler, V::Error>
8726                where
8727                    V: serde::de::MapAccess<'de>,
8728            {
8729                let mut level__ = None;
8730                let mut tasks__ = None;
8731                while let Some(k) = map_.next_key()? {
8732                    match k {
8733                        GeneratedField::Level => {
8734                            if level__.is_some() {
8735                                return Err(serde::de::Error::duplicate_field("level"));
8736                            }
8737                            level__ = 
8738                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8739                            ;
8740                        }
8741                        GeneratedField::Tasks => {
8742                            if tasks__.is_some() {
8743                                return Err(serde::de::Error::duplicate_field("tasks"));
8744                            }
8745                            tasks__ = Some(map_.next_value()?);
8746                        }
8747                    }
8748                }
8749                Ok(LevelHandler {
8750                    level: level__.unwrap_or_default(),
8751                    tasks: tasks__.unwrap_or_default(),
8752                })
8753            }
8754        }
8755        deserializer.deserialize_struct("hummock.LevelHandler", FIELDS, GeneratedVisitor)
8756    }
8757}
8758impl serde::Serialize for level_handler::RunningCompactTask {
8759    #[allow(deprecated)]
8760    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8761    where
8762        S: serde::Serializer,
8763    {
8764        use serde::ser::SerializeStruct;
8765        let mut len = 0;
8766        if self.task_id != 0 {
8767            len += 1;
8768        }
8769        if !self.ssts.is_empty() {
8770            len += 1;
8771        }
8772        if self.total_file_size != 0 {
8773            len += 1;
8774        }
8775        if self.target_level != 0 {
8776            len += 1;
8777        }
8778        let mut struct_ser = serializer.serialize_struct("hummock.LevelHandler.RunningCompactTask", len)?;
8779        if self.task_id != 0 {
8780            #[allow(clippy::needless_borrow)]
8781            #[allow(clippy::needless_borrows_for_generic_args)]
8782            struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
8783        }
8784        if !self.ssts.is_empty() {
8785            struct_ser.serialize_field("ssts", &self.ssts.iter().map(ToString::to_string).collect::<Vec<_>>())?;
8786        }
8787        if self.total_file_size != 0 {
8788            #[allow(clippy::needless_borrow)]
8789            #[allow(clippy::needless_borrows_for_generic_args)]
8790            struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
8791        }
8792        if self.target_level != 0 {
8793            struct_ser.serialize_field("targetLevel", &self.target_level)?;
8794        }
8795        struct_ser.end()
8796    }
8797}
8798impl<'de> serde::Deserialize<'de> for level_handler::RunningCompactTask {
8799    #[allow(deprecated)]
8800    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8801    where
8802        D: serde::Deserializer<'de>,
8803    {
8804        const FIELDS: &[&str] = &[
8805            "task_id",
8806            "taskId",
8807            "ssts",
8808            "total_file_size",
8809            "totalFileSize",
8810            "target_level",
8811            "targetLevel",
8812        ];
8813
8814        #[allow(clippy::enum_variant_names)]
8815        enum GeneratedField {
8816            TaskId,
8817            Ssts,
8818            TotalFileSize,
8819            TargetLevel,
8820        }
8821        impl<'de> serde::Deserialize<'de> for GeneratedField {
8822            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8823            where
8824                D: serde::Deserializer<'de>,
8825            {
8826                struct GeneratedVisitor;
8827
8828                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8829                    type Value = GeneratedField;
8830
8831                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8832                        write!(formatter, "expected one of: {:?}", &FIELDS)
8833                    }
8834
8835                    #[allow(unused_variables)]
8836                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8837                    where
8838                        E: serde::de::Error,
8839                    {
8840                        match value {
8841                            "taskId" | "task_id" => Ok(GeneratedField::TaskId),
8842                            "ssts" => Ok(GeneratedField::Ssts),
8843                            "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
8844                            "targetLevel" | "target_level" => Ok(GeneratedField::TargetLevel),
8845                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8846                        }
8847                    }
8848                }
8849                deserializer.deserialize_identifier(GeneratedVisitor)
8850            }
8851        }
8852        struct GeneratedVisitor;
8853        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8854            type Value = level_handler::RunningCompactTask;
8855
8856            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8857                formatter.write_str("struct hummock.LevelHandler.RunningCompactTask")
8858            }
8859
8860            fn visit_map<V>(self, mut map_: V) -> std::result::Result<level_handler::RunningCompactTask, V::Error>
8861                where
8862                    V: serde::de::MapAccess<'de>,
8863            {
8864                let mut task_id__ = None;
8865                let mut ssts__ = None;
8866                let mut total_file_size__ = None;
8867                let mut target_level__ = None;
8868                while let Some(k) = map_.next_key()? {
8869                    match k {
8870                        GeneratedField::TaskId => {
8871                            if task_id__.is_some() {
8872                                return Err(serde::de::Error::duplicate_field("taskId"));
8873                            }
8874                            task_id__ = 
8875                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8876                            ;
8877                        }
8878                        GeneratedField::Ssts => {
8879                            if ssts__.is_some() {
8880                                return Err(serde::de::Error::duplicate_field("ssts"));
8881                            }
8882                            ssts__ = 
8883                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8884                                    .into_iter().map(|x| x.0).collect())
8885                            ;
8886                        }
8887                        GeneratedField::TotalFileSize => {
8888                            if total_file_size__.is_some() {
8889                                return Err(serde::de::Error::duplicate_field("totalFileSize"));
8890                            }
8891                            total_file_size__ = 
8892                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8893                            ;
8894                        }
8895                        GeneratedField::TargetLevel => {
8896                            if target_level__.is_some() {
8897                                return Err(serde::de::Error::duplicate_field("targetLevel"));
8898                            }
8899                            target_level__ = 
8900                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8901                            ;
8902                        }
8903                    }
8904                }
8905                Ok(level_handler::RunningCompactTask {
8906                    task_id: task_id__.unwrap_or_default(),
8907                    ssts: ssts__.unwrap_or_default(),
8908                    total_file_size: total_file_size__.unwrap_or_default(),
8909                    target_level: target_level__.unwrap_or_default(),
8910                })
8911            }
8912        }
8913        deserializer.deserialize_struct("hummock.LevelHandler.RunningCompactTask", FIELDS, GeneratedVisitor)
8914    }
8915}
8916impl serde::Serialize for LevelType {
8917    #[allow(deprecated)]
8918    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8919    where
8920        S: serde::Serializer,
8921    {
8922        let variant = match self {
8923            Self::Unspecified => "LEVEL_TYPE_UNSPECIFIED",
8924            Self::Nonoverlapping => "LEVEL_TYPE_NONOVERLAPPING",
8925            Self::Overlapping => "LEVEL_TYPE_OVERLAPPING",
8926        };
8927        serializer.serialize_str(variant)
8928    }
8929}
8930impl<'de> serde::Deserialize<'de> for LevelType {
8931    #[allow(deprecated)]
8932    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8933    where
8934        D: serde::Deserializer<'de>,
8935    {
8936        const FIELDS: &[&str] = &[
8937            "LEVEL_TYPE_UNSPECIFIED",
8938            "LEVEL_TYPE_NONOVERLAPPING",
8939            "LEVEL_TYPE_OVERLAPPING",
8940        ];
8941
8942        struct GeneratedVisitor;
8943
8944        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8945            type Value = LevelType;
8946
8947            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8948                write!(formatter, "expected one of: {:?}", &FIELDS)
8949            }
8950
8951            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
8952            where
8953                E: serde::de::Error,
8954            {
8955                i32::try_from(v)
8956                    .ok()
8957                    .and_then(|x| x.try_into().ok())
8958                    .ok_or_else(|| {
8959                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
8960                    })
8961            }
8962
8963            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
8964            where
8965                E: serde::de::Error,
8966            {
8967                i32::try_from(v)
8968                    .ok()
8969                    .and_then(|x| x.try_into().ok())
8970                    .ok_or_else(|| {
8971                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
8972                    })
8973            }
8974
8975            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
8976            where
8977                E: serde::de::Error,
8978            {
8979                match value {
8980                    "LEVEL_TYPE_UNSPECIFIED" => Ok(LevelType::Unspecified),
8981                    "LEVEL_TYPE_NONOVERLAPPING" => Ok(LevelType::Nonoverlapping),
8982                    "LEVEL_TYPE_OVERLAPPING" => Ok(LevelType::Overlapping),
8983                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
8984                }
8985            }
8986        }
8987        deserializer.deserialize_any(GeneratedVisitor)
8988    }
8989}
8990impl serde::Serialize for ListActiveWriteLimitRequest {
8991    #[allow(deprecated)]
8992    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8993    where
8994        S: serde::Serializer,
8995    {
8996        use serde::ser::SerializeStruct;
8997        let len = 0;
8998        let struct_ser = serializer.serialize_struct("hummock.ListActiveWriteLimitRequest", len)?;
8999        struct_ser.end()
9000    }
9001}
9002impl<'de> serde::Deserialize<'de> for ListActiveWriteLimitRequest {
9003    #[allow(deprecated)]
9004    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9005    where
9006        D: serde::Deserializer<'de>,
9007    {
9008        const FIELDS: &[&str] = &[
9009        ];
9010
9011        #[allow(clippy::enum_variant_names)]
9012        enum GeneratedField {
9013        }
9014        impl<'de> serde::Deserialize<'de> for GeneratedField {
9015            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9016            where
9017                D: serde::Deserializer<'de>,
9018            {
9019                struct GeneratedVisitor;
9020
9021                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9022                    type Value = GeneratedField;
9023
9024                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9025                        write!(formatter, "expected one of: {:?}", &FIELDS)
9026                    }
9027
9028                    #[allow(unused_variables)]
9029                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9030                    where
9031                        E: serde::de::Error,
9032                    {
9033                            Err(serde::de::Error::unknown_field(value, FIELDS))
9034                    }
9035                }
9036                deserializer.deserialize_identifier(GeneratedVisitor)
9037            }
9038        }
9039        struct GeneratedVisitor;
9040        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9041            type Value = ListActiveWriteLimitRequest;
9042
9043            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9044                formatter.write_str("struct hummock.ListActiveWriteLimitRequest")
9045            }
9046
9047            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActiveWriteLimitRequest, V::Error>
9048                where
9049                    V: serde::de::MapAccess<'de>,
9050            {
9051                while map_.next_key::<GeneratedField>()?.is_some() {
9052                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9053                }
9054                Ok(ListActiveWriteLimitRequest {
9055                })
9056            }
9057        }
9058        deserializer.deserialize_struct("hummock.ListActiveWriteLimitRequest", FIELDS, GeneratedVisitor)
9059    }
9060}
9061impl serde::Serialize for ListActiveWriteLimitResponse {
9062    #[allow(deprecated)]
9063    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9064    where
9065        S: serde::Serializer,
9066    {
9067        use serde::ser::SerializeStruct;
9068        let mut len = 0;
9069        if !self.write_limits.is_empty() {
9070            len += 1;
9071        }
9072        let mut struct_ser = serializer.serialize_struct("hummock.ListActiveWriteLimitResponse", len)?;
9073        if !self.write_limits.is_empty() {
9074            struct_ser.serialize_field("writeLimits", &self.write_limits)?;
9075        }
9076        struct_ser.end()
9077    }
9078}
9079impl<'de> serde::Deserialize<'de> for ListActiveWriteLimitResponse {
9080    #[allow(deprecated)]
9081    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9082    where
9083        D: serde::Deserializer<'de>,
9084    {
9085        const FIELDS: &[&str] = &[
9086            "write_limits",
9087            "writeLimits",
9088        ];
9089
9090        #[allow(clippy::enum_variant_names)]
9091        enum GeneratedField {
9092            WriteLimits,
9093        }
9094        impl<'de> serde::Deserialize<'de> for GeneratedField {
9095            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9096            where
9097                D: serde::Deserializer<'de>,
9098            {
9099                struct GeneratedVisitor;
9100
9101                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9102                    type Value = GeneratedField;
9103
9104                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9105                        write!(formatter, "expected one of: {:?}", &FIELDS)
9106                    }
9107
9108                    #[allow(unused_variables)]
9109                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9110                    where
9111                        E: serde::de::Error,
9112                    {
9113                        match value {
9114                            "writeLimits" | "write_limits" => Ok(GeneratedField::WriteLimits),
9115                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9116                        }
9117                    }
9118                }
9119                deserializer.deserialize_identifier(GeneratedVisitor)
9120            }
9121        }
9122        struct GeneratedVisitor;
9123        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9124            type Value = ListActiveWriteLimitResponse;
9125
9126            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9127                formatter.write_str("struct hummock.ListActiveWriteLimitResponse")
9128            }
9129
9130            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActiveWriteLimitResponse, V::Error>
9131                where
9132                    V: serde::de::MapAccess<'de>,
9133            {
9134                let mut write_limits__ = None;
9135                while let Some(k) = map_.next_key()? {
9136                    match k {
9137                        GeneratedField::WriteLimits => {
9138                            if write_limits__.is_some() {
9139                                return Err(serde::de::Error::duplicate_field("writeLimits"));
9140                            }
9141                            write_limits__ = Some(
9142                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
9143                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
9144                            );
9145                        }
9146                    }
9147                }
9148                Ok(ListActiveWriteLimitResponse {
9149                    write_limits: write_limits__.unwrap_or_default(),
9150                })
9151            }
9152        }
9153        deserializer.deserialize_struct("hummock.ListActiveWriteLimitResponse", FIELDS, GeneratedVisitor)
9154    }
9155}
9156impl serde::Serialize for ListBranchedObjectRequest {
9157    #[allow(deprecated)]
9158    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9159    where
9160        S: serde::Serializer,
9161    {
9162        use serde::ser::SerializeStruct;
9163        let len = 0;
9164        let struct_ser = serializer.serialize_struct("hummock.ListBranchedObjectRequest", len)?;
9165        struct_ser.end()
9166    }
9167}
9168impl<'de> serde::Deserialize<'de> for ListBranchedObjectRequest {
9169    #[allow(deprecated)]
9170    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9171    where
9172        D: serde::Deserializer<'de>,
9173    {
9174        const FIELDS: &[&str] = &[
9175        ];
9176
9177        #[allow(clippy::enum_variant_names)]
9178        enum GeneratedField {
9179        }
9180        impl<'de> serde::Deserialize<'de> for GeneratedField {
9181            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9182            where
9183                D: serde::Deserializer<'de>,
9184            {
9185                struct GeneratedVisitor;
9186
9187                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9188                    type Value = GeneratedField;
9189
9190                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9191                        write!(formatter, "expected one of: {:?}", &FIELDS)
9192                    }
9193
9194                    #[allow(unused_variables)]
9195                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9196                    where
9197                        E: serde::de::Error,
9198                    {
9199                            Err(serde::de::Error::unknown_field(value, FIELDS))
9200                    }
9201                }
9202                deserializer.deserialize_identifier(GeneratedVisitor)
9203            }
9204        }
9205        struct GeneratedVisitor;
9206        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9207            type Value = ListBranchedObjectRequest;
9208
9209            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9210                formatter.write_str("struct hummock.ListBranchedObjectRequest")
9211            }
9212
9213            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListBranchedObjectRequest, V::Error>
9214                where
9215                    V: serde::de::MapAccess<'de>,
9216            {
9217                while map_.next_key::<GeneratedField>()?.is_some() {
9218                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9219                }
9220                Ok(ListBranchedObjectRequest {
9221                })
9222            }
9223        }
9224        deserializer.deserialize_struct("hummock.ListBranchedObjectRequest", FIELDS, GeneratedVisitor)
9225    }
9226}
9227impl serde::Serialize for ListBranchedObjectResponse {
9228    #[allow(deprecated)]
9229    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9230    where
9231        S: serde::Serializer,
9232    {
9233        use serde::ser::SerializeStruct;
9234        let mut len = 0;
9235        if !self.branched_objects.is_empty() {
9236            len += 1;
9237        }
9238        let mut struct_ser = serializer.serialize_struct("hummock.ListBranchedObjectResponse", len)?;
9239        if !self.branched_objects.is_empty() {
9240            struct_ser.serialize_field("branchedObjects", &self.branched_objects)?;
9241        }
9242        struct_ser.end()
9243    }
9244}
9245impl<'de> serde::Deserialize<'de> for ListBranchedObjectResponse {
9246    #[allow(deprecated)]
9247    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9248    where
9249        D: serde::Deserializer<'de>,
9250    {
9251        const FIELDS: &[&str] = &[
9252            "branched_objects",
9253            "branchedObjects",
9254        ];
9255
9256        #[allow(clippy::enum_variant_names)]
9257        enum GeneratedField {
9258            BranchedObjects,
9259        }
9260        impl<'de> serde::Deserialize<'de> for GeneratedField {
9261            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9262            where
9263                D: serde::Deserializer<'de>,
9264            {
9265                struct GeneratedVisitor;
9266
9267                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9268                    type Value = GeneratedField;
9269
9270                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9271                        write!(formatter, "expected one of: {:?}", &FIELDS)
9272                    }
9273
9274                    #[allow(unused_variables)]
9275                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9276                    where
9277                        E: serde::de::Error,
9278                    {
9279                        match value {
9280                            "branchedObjects" | "branched_objects" => Ok(GeneratedField::BranchedObjects),
9281                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9282                        }
9283                    }
9284                }
9285                deserializer.deserialize_identifier(GeneratedVisitor)
9286            }
9287        }
9288        struct GeneratedVisitor;
9289        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9290            type Value = ListBranchedObjectResponse;
9291
9292            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9293                formatter.write_str("struct hummock.ListBranchedObjectResponse")
9294            }
9295
9296            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListBranchedObjectResponse, V::Error>
9297                where
9298                    V: serde::de::MapAccess<'de>,
9299            {
9300                let mut branched_objects__ = None;
9301                while let Some(k) = map_.next_key()? {
9302                    match k {
9303                        GeneratedField::BranchedObjects => {
9304                            if branched_objects__.is_some() {
9305                                return Err(serde::de::Error::duplicate_field("branchedObjects"));
9306                            }
9307                            branched_objects__ = Some(map_.next_value()?);
9308                        }
9309                    }
9310                }
9311                Ok(ListBranchedObjectResponse {
9312                    branched_objects: branched_objects__.unwrap_or_default(),
9313                })
9314            }
9315        }
9316        deserializer.deserialize_struct("hummock.ListBranchedObjectResponse", FIELDS, GeneratedVisitor)
9317    }
9318}
9319impl serde::Serialize for ListCompactTaskAssignmentRequest {
9320    #[allow(deprecated)]
9321    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9322    where
9323        S: serde::Serializer,
9324    {
9325        use serde::ser::SerializeStruct;
9326        let len = 0;
9327        let struct_ser = serializer.serialize_struct("hummock.ListCompactTaskAssignmentRequest", len)?;
9328        struct_ser.end()
9329    }
9330}
9331impl<'de> serde::Deserialize<'de> for ListCompactTaskAssignmentRequest {
9332    #[allow(deprecated)]
9333    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9334    where
9335        D: serde::Deserializer<'de>,
9336    {
9337        const FIELDS: &[&str] = &[
9338        ];
9339
9340        #[allow(clippy::enum_variant_names)]
9341        enum GeneratedField {
9342        }
9343        impl<'de> serde::Deserialize<'de> for GeneratedField {
9344            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9345            where
9346                D: serde::Deserializer<'de>,
9347            {
9348                struct GeneratedVisitor;
9349
9350                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9351                    type Value = GeneratedField;
9352
9353                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9354                        write!(formatter, "expected one of: {:?}", &FIELDS)
9355                    }
9356
9357                    #[allow(unused_variables)]
9358                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9359                    where
9360                        E: serde::de::Error,
9361                    {
9362                            Err(serde::de::Error::unknown_field(value, FIELDS))
9363                    }
9364                }
9365                deserializer.deserialize_identifier(GeneratedVisitor)
9366            }
9367        }
9368        struct GeneratedVisitor;
9369        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9370            type Value = ListCompactTaskAssignmentRequest;
9371
9372            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9373                formatter.write_str("struct hummock.ListCompactTaskAssignmentRequest")
9374            }
9375
9376            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskAssignmentRequest, V::Error>
9377                where
9378                    V: serde::de::MapAccess<'de>,
9379            {
9380                while map_.next_key::<GeneratedField>()?.is_some() {
9381                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9382                }
9383                Ok(ListCompactTaskAssignmentRequest {
9384                })
9385            }
9386        }
9387        deserializer.deserialize_struct("hummock.ListCompactTaskAssignmentRequest", FIELDS, GeneratedVisitor)
9388    }
9389}
9390impl serde::Serialize for ListCompactTaskAssignmentResponse {
9391    #[allow(deprecated)]
9392    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9393    where
9394        S: serde::Serializer,
9395    {
9396        use serde::ser::SerializeStruct;
9397        let mut len = 0;
9398        if !self.task_assignment.is_empty() {
9399            len += 1;
9400        }
9401        let mut struct_ser = serializer.serialize_struct("hummock.ListCompactTaskAssignmentResponse", len)?;
9402        if !self.task_assignment.is_empty() {
9403            struct_ser.serialize_field("taskAssignment", &self.task_assignment)?;
9404        }
9405        struct_ser.end()
9406    }
9407}
9408impl<'de> serde::Deserialize<'de> for ListCompactTaskAssignmentResponse {
9409    #[allow(deprecated)]
9410    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9411    where
9412        D: serde::Deserializer<'de>,
9413    {
9414        const FIELDS: &[&str] = &[
9415            "task_assignment",
9416            "taskAssignment",
9417        ];
9418
9419        #[allow(clippy::enum_variant_names)]
9420        enum GeneratedField {
9421            TaskAssignment,
9422        }
9423        impl<'de> serde::Deserialize<'de> for GeneratedField {
9424            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9425            where
9426                D: serde::Deserializer<'de>,
9427            {
9428                struct GeneratedVisitor;
9429
9430                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9431                    type Value = GeneratedField;
9432
9433                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9434                        write!(formatter, "expected one of: {:?}", &FIELDS)
9435                    }
9436
9437                    #[allow(unused_variables)]
9438                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9439                    where
9440                        E: serde::de::Error,
9441                    {
9442                        match value {
9443                            "taskAssignment" | "task_assignment" => Ok(GeneratedField::TaskAssignment),
9444                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9445                        }
9446                    }
9447                }
9448                deserializer.deserialize_identifier(GeneratedVisitor)
9449            }
9450        }
9451        struct GeneratedVisitor;
9452        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9453            type Value = ListCompactTaskAssignmentResponse;
9454
9455            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9456                formatter.write_str("struct hummock.ListCompactTaskAssignmentResponse")
9457            }
9458
9459            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskAssignmentResponse, V::Error>
9460                where
9461                    V: serde::de::MapAccess<'de>,
9462            {
9463                let mut task_assignment__ = None;
9464                while let Some(k) = map_.next_key()? {
9465                    match k {
9466                        GeneratedField::TaskAssignment => {
9467                            if task_assignment__.is_some() {
9468                                return Err(serde::de::Error::duplicate_field("taskAssignment"));
9469                            }
9470                            task_assignment__ = Some(map_.next_value()?);
9471                        }
9472                    }
9473                }
9474                Ok(ListCompactTaskAssignmentResponse {
9475                    task_assignment: task_assignment__.unwrap_or_default(),
9476                })
9477            }
9478        }
9479        deserializer.deserialize_struct("hummock.ListCompactTaskAssignmentResponse", FIELDS, GeneratedVisitor)
9480    }
9481}
9482impl serde::Serialize for ListCompactTaskProgressRequest {
9483    #[allow(deprecated)]
9484    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9485    where
9486        S: serde::Serializer,
9487    {
9488        use serde::ser::SerializeStruct;
9489        let len = 0;
9490        let struct_ser = serializer.serialize_struct("hummock.ListCompactTaskProgressRequest", len)?;
9491        struct_ser.end()
9492    }
9493}
9494impl<'de> serde::Deserialize<'de> for ListCompactTaskProgressRequest {
9495    #[allow(deprecated)]
9496    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9497    where
9498        D: serde::Deserializer<'de>,
9499    {
9500        const FIELDS: &[&str] = &[
9501        ];
9502
9503        #[allow(clippy::enum_variant_names)]
9504        enum GeneratedField {
9505        }
9506        impl<'de> serde::Deserialize<'de> for GeneratedField {
9507            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9508            where
9509                D: serde::Deserializer<'de>,
9510            {
9511                struct GeneratedVisitor;
9512
9513                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9514                    type Value = GeneratedField;
9515
9516                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9517                        write!(formatter, "expected one of: {:?}", &FIELDS)
9518                    }
9519
9520                    #[allow(unused_variables)]
9521                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9522                    where
9523                        E: serde::de::Error,
9524                    {
9525                            Err(serde::de::Error::unknown_field(value, FIELDS))
9526                    }
9527                }
9528                deserializer.deserialize_identifier(GeneratedVisitor)
9529            }
9530        }
9531        struct GeneratedVisitor;
9532        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9533            type Value = ListCompactTaskProgressRequest;
9534
9535            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9536                formatter.write_str("struct hummock.ListCompactTaskProgressRequest")
9537            }
9538
9539            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskProgressRequest, V::Error>
9540                where
9541                    V: serde::de::MapAccess<'de>,
9542            {
9543                while map_.next_key::<GeneratedField>()?.is_some() {
9544                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9545                }
9546                Ok(ListCompactTaskProgressRequest {
9547                })
9548            }
9549        }
9550        deserializer.deserialize_struct("hummock.ListCompactTaskProgressRequest", FIELDS, GeneratedVisitor)
9551    }
9552}
9553impl serde::Serialize for ListCompactTaskProgressResponse {
9554    #[allow(deprecated)]
9555    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9556    where
9557        S: serde::Serializer,
9558    {
9559        use serde::ser::SerializeStruct;
9560        let mut len = 0;
9561        if !self.task_progress.is_empty() {
9562            len += 1;
9563        }
9564        let mut struct_ser = serializer.serialize_struct("hummock.ListCompactTaskProgressResponse", len)?;
9565        if !self.task_progress.is_empty() {
9566            struct_ser.serialize_field("taskProgress", &self.task_progress)?;
9567        }
9568        struct_ser.end()
9569    }
9570}
9571impl<'de> serde::Deserialize<'de> for ListCompactTaskProgressResponse {
9572    #[allow(deprecated)]
9573    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9574    where
9575        D: serde::Deserializer<'de>,
9576    {
9577        const FIELDS: &[&str] = &[
9578            "task_progress",
9579            "taskProgress",
9580        ];
9581
9582        #[allow(clippy::enum_variant_names)]
9583        enum GeneratedField {
9584            TaskProgress,
9585        }
9586        impl<'de> serde::Deserialize<'de> for GeneratedField {
9587            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9588            where
9589                D: serde::Deserializer<'de>,
9590            {
9591                struct GeneratedVisitor;
9592
9593                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9594                    type Value = GeneratedField;
9595
9596                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9597                        write!(formatter, "expected one of: {:?}", &FIELDS)
9598                    }
9599
9600                    #[allow(unused_variables)]
9601                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9602                    where
9603                        E: serde::de::Error,
9604                    {
9605                        match value {
9606                            "taskProgress" | "task_progress" => Ok(GeneratedField::TaskProgress),
9607                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9608                        }
9609                    }
9610                }
9611                deserializer.deserialize_identifier(GeneratedVisitor)
9612            }
9613        }
9614        struct GeneratedVisitor;
9615        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9616            type Value = ListCompactTaskProgressResponse;
9617
9618            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9619                formatter.write_str("struct hummock.ListCompactTaskProgressResponse")
9620            }
9621
9622            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskProgressResponse, V::Error>
9623                where
9624                    V: serde::de::MapAccess<'de>,
9625            {
9626                let mut task_progress__ = None;
9627                while let Some(k) = map_.next_key()? {
9628                    match k {
9629                        GeneratedField::TaskProgress => {
9630                            if task_progress__.is_some() {
9631                                return Err(serde::de::Error::duplicate_field("taskProgress"));
9632                            }
9633                            task_progress__ = Some(map_.next_value()?);
9634                        }
9635                    }
9636                }
9637                Ok(ListCompactTaskProgressResponse {
9638                    task_progress: task_progress__.unwrap_or_default(),
9639                })
9640            }
9641        }
9642        deserializer.deserialize_struct("hummock.ListCompactTaskProgressResponse", FIELDS, GeneratedVisitor)
9643    }
9644}
9645impl serde::Serialize for ListHummockMetaConfigRequest {
9646    #[allow(deprecated)]
9647    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9648    where
9649        S: serde::Serializer,
9650    {
9651        use serde::ser::SerializeStruct;
9652        let len = 0;
9653        let struct_ser = serializer.serialize_struct("hummock.ListHummockMetaConfigRequest", len)?;
9654        struct_ser.end()
9655    }
9656}
9657impl<'de> serde::Deserialize<'de> for ListHummockMetaConfigRequest {
9658    #[allow(deprecated)]
9659    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9660    where
9661        D: serde::Deserializer<'de>,
9662    {
9663        const FIELDS: &[&str] = &[
9664        ];
9665
9666        #[allow(clippy::enum_variant_names)]
9667        enum GeneratedField {
9668        }
9669        impl<'de> serde::Deserialize<'de> for GeneratedField {
9670            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9671            where
9672                D: serde::Deserializer<'de>,
9673            {
9674                struct GeneratedVisitor;
9675
9676                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9677                    type Value = GeneratedField;
9678
9679                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9680                        write!(formatter, "expected one of: {:?}", &FIELDS)
9681                    }
9682
9683                    #[allow(unused_variables)]
9684                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9685                    where
9686                        E: serde::de::Error,
9687                    {
9688                            Err(serde::de::Error::unknown_field(value, FIELDS))
9689                    }
9690                }
9691                deserializer.deserialize_identifier(GeneratedVisitor)
9692            }
9693        }
9694        struct GeneratedVisitor;
9695        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9696            type Value = ListHummockMetaConfigRequest;
9697
9698            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9699                formatter.write_str("struct hummock.ListHummockMetaConfigRequest")
9700            }
9701
9702            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListHummockMetaConfigRequest, V::Error>
9703                where
9704                    V: serde::de::MapAccess<'de>,
9705            {
9706                while map_.next_key::<GeneratedField>()?.is_some() {
9707                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9708                }
9709                Ok(ListHummockMetaConfigRequest {
9710                })
9711            }
9712        }
9713        deserializer.deserialize_struct("hummock.ListHummockMetaConfigRequest", FIELDS, GeneratedVisitor)
9714    }
9715}
9716impl serde::Serialize for ListHummockMetaConfigResponse {
9717    #[allow(deprecated)]
9718    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9719    where
9720        S: serde::Serializer,
9721    {
9722        use serde::ser::SerializeStruct;
9723        let mut len = 0;
9724        if !self.configs.is_empty() {
9725            len += 1;
9726        }
9727        let mut struct_ser = serializer.serialize_struct("hummock.ListHummockMetaConfigResponse", len)?;
9728        if !self.configs.is_empty() {
9729            struct_ser.serialize_field("configs", &self.configs)?;
9730        }
9731        struct_ser.end()
9732    }
9733}
9734impl<'de> serde::Deserialize<'de> for ListHummockMetaConfigResponse {
9735    #[allow(deprecated)]
9736    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9737    where
9738        D: serde::Deserializer<'de>,
9739    {
9740        const FIELDS: &[&str] = &[
9741            "configs",
9742        ];
9743
9744        #[allow(clippy::enum_variant_names)]
9745        enum GeneratedField {
9746            Configs,
9747        }
9748        impl<'de> serde::Deserialize<'de> for GeneratedField {
9749            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9750            where
9751                D: serde::Deserializer<'de>,
9752            {
9753                struct GeneratedVisitor;
9754
9755                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9756                    type Value = GeneratedField;
9757
9758                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9759                        write!(formatter, "expected one of: {:?}", &FIELDS)
9760                    }
9761
9762                    #[allow(unused_variables)]
9763                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9764                    where
9765                        E: serde::de::Error,
9766                    {
9767                        match value {
9768                            "configs" => Ok(GeneratedField::Configs),
9769                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9770                        }
9771                    }
9772                }
9773                deserializer.deserialize_identifier(GeneratedVisitor)
9774            }
9775        }
9776        struct GeneratedVisitor;
9777        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9778            type Value = ListHummockMetaConfigResponse;
9779
9780            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9781                formatter.write_str("struct hummock.ListHummockMetaConfigResponse")
9782            }
9783
9784            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListHummockMetaConfigResponse, V::Error>
9785                where
9786                    V: serde::de::MapAccess<'de>,
9787            {
9788                let mut configs__ = None;
9789                while let Some(k) = map_.next_key()? {
9790                    match k {
9791                        GeneratedField::Configs => {
9792                            if configs__.is_some() {
9793                                return Err(serde::de::Error::duplicate_field("configs"));
9794                            }
9795                            configs__ = Some(
9796                                map_.next_value::<std::collections::HashMap<_, _>>()?
9797                            );
9798                        }
9799                    }
9800                }
9801                Ok(ListHummockMetaConfigResponse {
9802                    configs: configs__.unwrap_or_default(),
9803                })
9804            }
9805        }
9806        deserializer.deserialize_struct("hummock.ListHummockMetaConfigResponse", FIELDS, GeneratedVisitor)
9807    }
9808}
9809impl serde::Serialize for ListVersionDeltasRequest {
9810    #[allow(deprecated)]
9811    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9812    where
9813        S: serde::Serializer,
9814    {
9815        use serde::ser::SerializeStruct;
9816        let mut len = 0;
9817        if self.start_id != 0 {
9818            len += 1;
9819        }
9820        if self.num_limit != 0 {
9821            len += 1;
9822        }
9823        if self.committed_epoch_limit != 0 {
9824            len += 1;
9825        }
9826        let mut struct_ser = serializer.serialize_struct("hummock.ListVersionDeltasRequest", len)?;
9827        if self.start_id != 0 {
9828            #[allow(clippy::needless_borrow)]
9829            #[allow(clippy::needless_borrows_for_generic_args)]
9830            struct_ser.serialize_field("startId", ToString::to_string(&self.start_id).as_str())?;
9831        }
9832        if self.num_limit != 0 {
9833            struct_ser.serialize_field("numLimit", &self.num_limit)?;
9834        }
9835        if self.committed_epoch_limit != 0 {
9836            #[allow(clippy::needless_borrow)]
9837            #[allow(clippy::needless_borrows_for_generic_args)]
9838            struct_ser.serialize_field("committedEpochLimit", ToString::to_string(&self.committed_epoch_limit).as_str())?;
9839        }
9840        struct_ser.end()
9841    }
9842}
9843impl<'de> serde::Deserialize<'de> for ListVersionDeltasRequest {
9844    #[allow(deprecated)]
9845    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9846    where
9847        D: serde::Deserializer<'de>,
9848    {
9849        const FIELDS: &[&str] = &[
9850            "start_id",
9851            "startId",
9852            "num_limit",
9853            "numLimit",
9854            "committed_epoch_limit",
9855            "committedEpochLimit",
9856        ];
9857
9858        #[allow(clippy::enum_variant_names)]
9859        enum GeneratedField {
9860            StartId,
9861            NumLimit,
9862            CommittedEpochLimit,
9863        }
9864        impl<'de> serde::Deserialize<'de> for GeneratedField {
9865            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9866            where
9867                D: serde::Deserializer<'de>,
9868            {
9869                struct GeneratedVisitor;
9870
9871                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9872                    type Value = GeneratedField;
9873
9874                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9875                        write!(formatter, "expected one of: {:?}", &FIELDS)
9876                    }
9877
9878                    #[allow(unused_variables)]
9879                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9880                    where
9881                        E: serde::de::Error,
9882                    {
9883                        match value {
9884                            "startId" | "start_id" => Ok(GeneratedField::StartId),
9885                            "numLimit" | "num_limit" => Ok(GeneratedField::NumLimit),
9886                            "committedEpochLimit" | "committed_epoch_limit" => Ok(GeneratedField::CommittedEpochLimit),
9887                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9888                        }
9889                    }
9890                }
9891                deserializer.deserialize_identifier(GeneratedVisitor)
9892            }
9893        }
9894        struct GeneratedVisitor;
9895        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9896            type Value = ListVersionDeltasRequest;
9897
9898            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9899                formatter.write_str("struct hummock.ListVersionDeltasRequest")
9900            }
9901
9902            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListVersionDeltasRequest, V::Error>
9903                where
9904                    V: serde::de::MapAccess<'de>,
9905            {
9906                let mut start_id__ = None;
9907                let mut num_limit__ = None;
9908                let mut committed_epoch_limit__ = None;
9909                while let Some(k) = map_.next_key()? {
9910                    match k {
9911                        GeneratedField::StartId => {
9912                            if start_id__.is_some() {
9913                                return Err(serde::de::Error::duplicate_field("startId"));
9914                            }
9915                            start_id__ = 
9916                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9917                            ;
9918                        }
9919                        GeneratedField::NumLimit => {
9920                            if num_limit__.is_some() {
9921                                return Err(serde::de::Error::duplicate_field("numLimit"));
9922                            }
9923                            num_limit__ = 
9924                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9925                            ;
9926                        }
9927                        GeneratedField::CommittedEpochLimit => {
9928                            if committed_epoch_limit__.is_some() {
9929                                return Err(serde::de::Error::duplicate_field("committedEpochLimit"));
9930                            }
9931                            committed_epoch_limit__ = 
9932                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9933                            ;
9934                        }
9935                    }
9936                }
9937                Ok(ListVersionDeltasRequest {
9938                    start_id: start_id__.unwrap_or_default(),
9939                    num_limit: num_limit__.unwrap_or_default(),
9940                    committed_epoch_limit: committed_epoch_limit__.unwrap_or_default(),
9941                })
9942            }
9943        }
9944        deserializer.deserialize_struct("hummock.ListVersionDeltasRequest", FIELDS, GeneratedVisitor)
9945    }
9946}
9947impl serde::Serialize for ListVersionDeltasResponse {
9948    #[allow(deprecated)]
9949    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9950    where
9951        S: serde::Serializer,
9952    {
9953        use serde::ser::SerializeStruct;
9954        let mut len = 0;
9955        if self.version_deltas.is_some() {
9956            len += 1;
9957        }
9958        let mut struct_ser = serializer.serialize_struct("hummock.ListVersionDeltasResponse", len)?;
9959        if let Some(v) = self.version_deltas.as_ref() {
9960            struct_ser.serialize_field("versionDeltas", v)?;
9961        }
9962        struct_ser.end()
9963    }
9964}
9965impl<'de> serde::Deserialize<'de> for ListVersionDeltasResponse {
9966    #[allow(deprecated)]
9967    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9968    where
9969        D: serde::Deserializer<'de>,
9970    {
9971        const FIELDS: &[&str] = &[
9972            "version_deltas",
9973            "versionDeltas",
9974        ];
9975
9976        #[allow(clippy::enum_variant_names)]
9977        enum GeneratedField {
9978            VersionDeltas,
9979        }
9980        impl<'de> serde::Deserialize<'de> for GeneratedField {
9981            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9982            where
9983                D: serde::Deserializer<'de>,
9984            {
9985                struct GeneratedVisitor;
9986
9987                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9988                    type Value = GeneratedField;
9989
9990                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9991                        write!(formatter, "expected one of: {:?}", &FIELDS)
9992                    }
9993
9994                    #[allow(unused_variables)]
9995                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9996                    where
9997                        E: serde::de::Error,
9998                    {
9999                        match value {
10000                            "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
10001                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10002                        }
10003                    }
10004                }
10005                deserializer.deserialize_identifier(GeneratedVisitor)
10006            }
10007        }
10008        struct GeneratedVisitor;
10009        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10010            type Value = ListVersionDeltasResponse;
10011
10012            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10013                formatter.write_str("struct hummock.ListVersionDeltasResponse")
10014            }
10015
10016            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListVersionDeltasResponse, V::Error>
10017                where
10018                    V: serde::de::MapAccess<'de>,
10019            {
10020                let mut version_deltas__ = None;
10021                while let Some(k) = map_.next_key()? {
10022                    match k {
10023                        GeneratedField::VersionDeltas => {
10024                            if version_deltas__.is_some() {
10025                                return Err(serde::de::Error::duplicate_field("versionDeltas"));
10026                            }
10027                            version_deltas__ = map_.next_value()?;
10028                        }
10029                    }
10030                }
10031                Ok(ListVersionDeltasResponse {
10032                    version_deltas: version_deltas__,
10033                })
10034            }
10035        }
10036        deserializer.deserialize_struct("hummock.ListVersionDeltasResponse", FIELDS, GeneratedVisitor)
10037    }
10038}
10039impl serde::Serialize for MergeCompactionGroupRequest {
10040    #[allow(deprecated)]
10041    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10042    where
10043        S: serde::Serializer,
10044    {
10045        use serde::ser::SerializeStruct;
10046        let mut len = 0;
10047        if self.left_group_id != 0 {
10048            len += 1;
10049        }
10050        if self.right_group_id != 0 {
10051            len += 1;
10052        }
10053        let mut struct_ser = serializer.serialize_struct("hummock.MergeCompactionGroupRequest", len)?;
10054        if self.left_group_id != 0 {
10055            #[allow(clippy::needless_borrow)]
10056            #[allow(clippy::needless_borrows_for_generic_args)]
10057            struct_ser.serialize_field("leftGroupId", ToString::to_string(&self.left_group_id).as_str())?;
10058        }
10059        if self.right_group_id != 0 {
10060            #[allow(clippy::needless_borrow)]
10061            #[allow(clippy::needless_borrows_for_generic_args)]
10062            struct_ser.serialize_field("rightGroupId", ToString::to_string(&self.right_group_id).as_str())?;
10063        }
10064        struct_ser.end()
10065    }
10066}
10067impl<'de> serde::Deserialize<'de> for MergeCompactionGroupRequest {
10068    #[allow(deprecated)]
10069    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10070    where
10071        D: serde::Deserializer<'de>,
10072    {
10073        const FIELDS: &[&str] = &[
10074            "left_group_id",
10075            "leftGroupId",
10076            "right_group_id",
10077            "rightGroupId",
10078        ];
10079
10080        #[allow(clippy::enum_variant_names)]
10081        enum GeneratedField {
10082            LeftGroupId,
10083            RightGroupId,
10084        }
10085        impl<'de> serde::Deserialize<'de> for GeneratedField {
10086            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10087            where
10088                D: serde::Deserializer<'de>,
10089            {
10090                struct GeneratedVisitor;
10091
10092                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10093                    type Value = GeneratedField;
10094
10095                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10096                        write!(formatter, "expected one of: {:?}", &FIELDS)
10097                    }
10098
10099                    #[allow(unused_variables)]
10100                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10101                    where
10102                        E: serde::de::Error,
10103                    {
10104                        match value {
10105                            "leftGroupId" | "left_group_id" => Ok(GeneratedField::LeftGroupId),
10106                            "rightGroupId" | "right_group_id" => Ok(GeneratedField::RightGroupId),
10107                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10108                        }
10109                    }
10110                }
10111                deserializer.deserialize_identifier(GeneratedVisitor)
10112            }
10113        }
10114        struct GeneratedVisitor;
10115        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10116            type Value = MergeCompactionGroupRequest;
10117
10118            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10119                formatter.write_str("struct hummock.MergeCompactionGroupRequest")
10120            }
10121
10122            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeCompactionGroupRequest, V::Error>
10123                where
10124                    V: serde::de::MapAccess<'de>,
10125            {
10126                let mut left_group_id__ = None;
10127                let mut right_group_id__ = None;
10128                while let Some(k) = map_.next_key()? {
10129                    match k {
10130                        GeneratedField::LeftGroupId => {
10131                            if left_group_id__.is_some() {
10132                                return Err(serde::de::Error::duplicate_field("leftGroupId"));
10133                            }
10134                            left_group_id__ = 
10135                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10136                            ;
10137                        }
10138                        GeneratedField::RightGroupId => {
10139                            if right_group_id__.is_some() {
10140                                return Err(serde::de::Error::duplicate_field("rightGroupId"));
10141                            }
10142                            right_group_id__ = 
10143                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10144                            ;
10145                        }
10146                    }
10147                }
10148                Ok(MergeCompactionGroupRequest {
10149                    left_group_id: left_group_id__.unwrap_or_default(),
10150                    right_group_id: right_group_id__.unwrap_or_default(),
10151                })
10152            }
10153        }
10154        deserializer.deserialize_struct("hummock.MergeCompactionGroupRequest", FIELDS, GeneratedVisitor)
10155    }
10156}
10157impl serde::Serialize for MergeCompactionGroupResponse {
10158    #[allow(deprecated)]
10159    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10160    where
10161        S: serde::Serializer,
10162    {
10163        use serde::ser::SerializeStruct;
10164        let len = 0;
10165        let struct_ser = serializer.serialize_struct("hummock.MergeCompactionGroupResponse", len)?;
10166        struct_ser.end()
10167    }
10168}
10169impl<'de> serde::Deserialize<'de> for MergeCompactionGroupResponse {
10170    #[allow(deprecated)]
10171    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10172    where
10173        D: serde::Deserializer<'de>,
10174    {
10175        const FIELDS: &[&str] = &[
10176        ];
10177
10178        #[allow(clippy::enum_variant_names)]
10179        enum GeneratedField {
10180        }
10181        impl<'de> serde::Deserialize<'de> for GeneratedField {
10182            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10183            where
10184                D: serde::Deserializer<'de>,
10185            {
10186                struct GeneratedVisitor;
10187
10188                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10189                    type Value = GeneratedField;
10190
10191                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10192                        write!(formatter, "expected one of: {:?}", &FIELDS)
10193                    }
10194
10195                    #[allow(unused_variables)]
10196                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10197                    where
10198                        E: serde::de::Error,
10199                    {
10200                            Err(serde::de::Error::unknown_field(value, FIELDS))
10201                    }
10202                }
10203                deserializer.deserialize_identifier(GeneratedVisitor)
10204            }
10205        }
10206        struct GeneratedVisitor;
10207        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10208            type Value = MergeCompactionGroupResponse;
10209
10210            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10211                formatter.write_str("struct hummock.MergeCompactionGroupResponse")
10212            }
10213
10214            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeCompactionGroupResponse, V::Error>
10215                where
10216                    V: serde::de::MapAccess<'de>,
10217            {
10218                while map_.next_key::<GeneratedField>()?.is_some() {
10219                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10220                }
10221                Ok(MergeCompactionGroupResponse {
10222                })
10223            }
10224        }
10225        deserializer.deserialize_struct("hummock.MergeCompactionGroupResponse", FIELDS, GeneratedVisitor)
10226    }
10227}
10228impl serde::Serialize for NewL0SubLevel {
10229    #[allow(deprecated)]
10230    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10231    where
10232        S: serde::Serializer,
10233    {
10234        use serde::ser::SerializeStruct;
10235        let mut len = 0;
10236        if !self.inserted_table_infos.is_empty() {
10237            len += 1;
10238        }
10239        let mut struct_ser = serializer.serialize_struct("hummock.NewL0SubLevel", len)?;
10240        if !self.inserted_table_infos.is_empty() {
10241            struct_ser.serialize_field("insertedTableInfos", &self.inserted_table_infos)?;
10242        }
10243        struct_ser.end()
10244    }
10245}
10246impl<'de> serde::Deserialize<'de> for NewL0SubLevel {
10247    #[allow(deprecated)]
10248    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10249    where
10250        D: serde::Deserializer<'de>,
10251    {
10252        const FIELDS: &[&str] = &[
10253            "inserted_table_infos",
10254            "insertedTableInfos",
10255        ];
10256
10257        #[allow(clippy::enum_variant_names)]
10258        enum GeneratedField {
10259            InsertedTableInfos,
10260        }
10261        impl<'de> serde::Deserialize<'de> for GeneratedField {
10262            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10263            where
10264                D: serde::Deserializer<'de>,
10265            {
10266                struct GeneratedVisitor;
10267
10268                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10269                    type Value = GeneratedField;
10270
10271                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10272                        write!(formatter, "expected one of: {:?}", &FIELDS)
10273                    }
10274
10275                    #[allow(unused_variables)]
10276                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10277                    where
10278                        E: serde::de::Error,
10279                    {
10280                        match value {
10281                            "insertedTableInfos" | "inserted_table_infos" => Ok(GeneratedField::InsertedTableInfos),
10282                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10283                        }
10284                    }
10285                }
10286                deserializer.deserialize_identifier(GeneratedVisitor)
10287            }
10288        }
10289        struct GeneratedVisitor;
10290        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10291            type Value = NewL0SubLevel;
10292
10293            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10294                formatter.write_str("struct hummock.NewL0SubLevel")
10295            }
10296
10297            fn visit_map<V>(self, mut map_: V) -> std::result::Result<NewL0SubLevel, V::Error>
10298                where
10299                    V: serde::de::MapAccess<'de>,
10300            {
10301                let mut inserted_table_infos__ = None;
10302                while let Some(k) = map_.next_key()? {
10303                    match k {
10304                        GeneratedField::InsertedTableInfos => {
10305                            if inserted_table_infos__.is_some() {
10306                                return Err(serde::de::Error::duplicate_field("insertedTableInfos"));
10307                            }
10308                            inserted_table_infos__ = Some(map_.next_value()?);
10309                        }
10310                    }
10311                }
10312                Ok(NewL0SubLevel {
10313                    inserted_table_infos: inserted_table_infos__.unwrap_or_default(),
10314                })
10315            }
10316        }
10317        deserializer.deserialize_struct("hummock.NewL0SubLevel", FIELDS, GeneratedVisitor)
10318    }
10319}
10320impl serde::Serialize for OverlappingLevel {
10321    #[allow(deprecated)]
10322    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10323    where
10324        S: serde::Serializer,
10325    {
10326        use serde::ser::SerializeStruct;
10327        let mut len = 0;
10328        if !self.sub_levels.is_empty() {
10329            len += 1;
10330        }
10331        if self.total_file_size != 0 {
10332            len += 1;
10333        }
10334        if self.uncompressed_file_size != 0 {
10335            len += 1;
10336        }
10337        let mut struct_ser = serializer.serialize_struct("hummock.OverlappingLevel", len)?;
10338        if !self.sub_levels.is_empty() {
10339            struct_ser.serialize_field("subLevels", &self.sub_levels)?;
10340        }
10341        if self.total_file_size != 0 {
10342            #[allow(clippy::needless_borrow)]
10343            #[allow(clippy::needless_borrows_for_generic_args)]
10344            struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
10345        }
10346        if self.uncompressed_file_size != 0 {
10347            #[allow(clippy::needless_borrow)]
10348            #[allow(clippy::needless_borrows_for_generic_args)]
10349            struct_ser.serialize_field("uncompressedFileSize", ToString::to_string(&self.uncompressed_file_size).as_str())?;
10350        }
10351        struct_ser.end()
10352    }
10353}
10354impl<'de> serde::Deserialize<'de> for OverlappingLevel {
10355    #[allow(deprecated)]
10356    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10357    where
10358        D: serde::Deserializer<'de>,
10359    {
10360        const FIELDS: &[&str] = &[
10361            "sub_levels",
10362            "subLevels",
10363            "total_file_size",
10364            "totalFileSize",
10365            "uncompressed_file_size",
10366            "uncompressedFileSize",
10367        ];
10368
10369        #[allow(clippy::enum_variant_names)]
10370        enum GeneratedField {
10371            SubLevels,
10372            TotalFileSize,
10373            UncompressedFileSize,
10374        }
10375        impl<'de> serde::Deserialize<'de> for GeneratedField {
10376            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10377            where
10378                D: serde::Deserializer<'de>,
10379            {
10380                struct GeneratedVisitor;
10381
10382                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10383                    type Value = GeneratedField;
10384
10385                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10386                        write!(formatter, "expected one of: {:?}", &FIELDS)
10387                    }
10388
10389                    #[allow(unused_variables)]
10390                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10391                    where
10392                        E: serde::de::Error,
10393                    {
10394                        match value {
10395                            "subLevels" | "sub_levels" => Ok(GeneratedField::SubLevels),
10396                            "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
10397                            "uncompressedFileSize" | "uncompressed_file_size" => Ok(GeneratedField::UncompressedFileSize),
10398                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10399                        }
10400                    }
10401                }
10402                deserializer.deserialize_identifier(GeneratedVisitor)
10403            }
10404        }
10405        struct GeneratedVisitor;
10406        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10407            type Value = OverlappingLevel;
10408
10409            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10410                formatter.write_str("struct hummock.OverlappingLevel")
10411            }
10412
10413            fn visit_map<V>(self, mut map_: V) -> std::result::Result<OverlappingLevel, V::Error>
10414                where
10415                    V: serde::de::MapAccess<'de>,
10416            {
10417                let mut sub_levels__ = None;
10418                let mut total_file_size__ = None;
10419                let mut uncompressed_file_size__ = None;
10420                while let Some(k) = map_.next_key()? {
10421                    match k {
10422                        GeneratedField::SubLevels => {
10423                            if sub_levels__.is_some() {
10424                                return Err(serde::de::Error::duplicate_field("subLevels"));
10425                            }
10426                            sub_levels__ = Some(map_.next_value()?);
10427                        }
10428                        GeneratedField::TotalFileSize => {
10429                            if total_file_size__.is_some() {
10430                                return Err(serde::de::Error::duplicate_field("totalFileSize"));
10431                            }
10432                            total_file_size__ = 
10433                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10434                            ;
10435                        }
10436                        GeneratedField::UncompressedFileSize => {
10437                            if uncompressed_file_size__.is_some() {
10438                                return Err(serde::de::Error::duplicate_field("uncompressedFileSize"));
10439                            }
10440                            uncompressed_file_size__ = 
10441                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10442                            ;
10443                        }
10444                    }
10445                }
10446                Ok(OverlappingLevel {
10447                    sub_levels: sub_levels__.unwrap_or_default(),
10448                    total_file_size: total_file_size__.unwrap_or_default(),
10449                    uncompressed_file_size: uncompressed_file_size__.unwrap_or_default(),
10450                })
10451            }
10452        }
10453        deserializer.deserialize_struct("hummock.OverlappingLevel", FIELDS, GeneratedVisitor)
10454    }
10455}
10456impl serde::Serialize for PinVersionRequest {
10457    #[allow(deprecated)]
10458    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10459    where
10460        S: serde::Serializer,
10461    {
10462        use serde::ser::SerializeStruct;
10463        let mut len = 0;
10464        if self.context_id != 0 {
10465            len += 1;
10466        }
10467        let mut struct_ser = serializer.serialize_struct("hummock.PinVersionRequest", len)?;
10468        if self.context_id != 0 {
10469            struct_ser.serialize_field("contextId", &self.context_id)?;
10470        }
10471        struct_ser.end()
10472    }
10473}
10474impl<'de> serde::Deserialize<'de> for PinVersionRequest {
10475    #[allow(deprecated)]
10476    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10477    where
10478        D: serde::Deserializer<'de>,
10479    {
10480        const FIELDS: &[&str] = &[
10481            "context_id",
10482            "contextId",
10483        ];
10484
10485        #[allow(clippy::enum_variant_names)]
10486        enum GeneratedField {
10487            ContextId,
10488        }
10489        impl<'de> serde::Deserialize<'de> for GeneratedField {
10490            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10491            where
10492                D: serde::Deserializer<'de>,
10493            {
10494                struct GeneratedVisitor;
10495
10496                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10497                    type Value = GeneratedField;
10498
10499                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10500                        write!(formatter, "expected one of: {:?}", &FIELDS)
10501                    }
10502
10503                    #[allow(unused_variables)]
10504                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10505                    where
10506                        E: serde::de::Error,
10507                    {
10508                        match value {
10509                            "contextId" | "context_id" => Ok(GeneratedField::ContextId),
10510                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10511                        }
10512                    }
10513                }
10514                deserializer.deserialize_identifier(GeneratedVisitor)
10515            }
10516        }
10517        struct GeneratedVisitor;
10518        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10519            type Value = PinVersionRequest;
10520
10521            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10522                formatter.write_str("struct hummock.PinVersionRequest")
10523            }
10524
10525            fn visit_map<V>(self, mut map_: V) -> std::result::Result<PinVersionRequest, V::Error>
10526                where
10527                    V: serde::de::MapAccess<'de>,
10528            {
10529                let mut context_id__ = None;
10530                while let Some(k) = map_.next_key()? {
10531                    match k {
10532                        GeneratedField::ContextId => {
10533                            if context_id__.is_some() {
10534                                return Err(serde::de::Error::duplicate_field("contextId"));
10535                            }
10536                            context_id__ = 
10537                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10538                            ;
10539                        }
10540                    }
10541                }
10542                Ok(PinVersionRequest {
10543                    context_id: context_id__.unwrap_or_default(),
10544                })
10545            }
10546        }
10547        deserializer.deserialize_struct("hummock.PinVersionRequest", FIELDS, GeneratedVisitor)
10548    }
10549}
10550impl serde::Serialize for PinVersionResponse {
10551    #[allow(deprecated)]
10552    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10553    where
10554        S: serde::Serializer,
10555    {
10556        use serde::ser::SerializeStruct;
10557        let mut len = 0;
10558        if self.pinned_version.is_some() {
10559            len += 1;
10560        }
10561        let mut struct_ser = serializer.serialize_struct("hummock.PinVersionResponse", len)?;
10562        if let Some(v) = self.pinned_version.as_ref() {
10563            struct_ser.serialize_field("pinnedVersion", v)?;
10564        }
10565        struct_ser.end()
10566    }
10567}
10568impl<'de> serde::Deserialize<'de> for PinVersionResponse {
10569    #[allow(deprecated)]
10570    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10571    where
10572        D: serde::Deserializer<'de>,
10573    {
10574        const FIELDS: &[&str] = &[
10575            "pinned_version",
10576            "pinnedVersion",
10577        ];
10578
10579        #[allow(clippy::enum_variant_names)]
10580        enum GeneratedField {
10581            PinnedVersion,
10582        }
10583        impl<'de> serde::Deserialize<'de> for GeneratedField {
10584            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10585            where
10586                D: serde::Deserializer<'de>,
10587            {
10588                struct GeneratedVisitor;
10589
10590                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10591                    type Value = GeneratedField;
10592
10593                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10594                        write!(formatter, "expected one of: {:?}", &FIELDS)
10595                    }
10596
10597                    #[allow(unused_variables)]
10598                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10599                    where
10600                        E: serde::de::Error,
10601                    {
10602                        match value {
10603                            "pinnedVersion" | "pinned_version" => Ok(GeneratedField::PinnedVersion),
10604                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10605                        }
10606                    }
10607                }
10608                deserializer.deserialize_identifier(GeneratedVisitor)
10609            }
10610        }
10611        struct GeneratedVisitor;
10612        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10613            type Value = PinVersionResponse;
10614
10615            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10616                formatter.write_str("struct hummock.PinVersionResponse")
10617            }
10618
10619            fn visit_map<V>(self, mut map_: V) -> std::result::Result<PinVersionResponse, V::Error>
10620                where
10621                    V: serde::de::MapAccess<'de>,
10622            {
10623                let mut pinned_version__ = None;
10624                while let Some(k) = map_.next_key()? {
10625                    match k {
10626                        GeneratedField::PinnedVersion => {
10627                            if pinned_version__.is_some() {
10628                                return Err(serde::de::Error::duplicate_field("pinnedVersion"));
10629                            }
10630                            pinned_version__ = map_.next_value()?;
10631                        }
10632                    }
10633                }
10634                Ok(PinVersionResponse {
10635                    pinned_version: pinned_version__,
10636                })
10637            }
10638        }
10639        deserializer.deserialize_struct("hummock.PinVersionResponse", FIELDS, GeneratedVisitor)
10640    }
10641}
10642impl serde::Serialize for PinnedVersionsSummary {
10643    #[allow(deprecated)]
10644    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10645    where
10646        S: serde::Serializer,
10647    {
10648        use serde::ser::SerializeStruct;
10649        let mut len = 0;
10650        if !self.pinned_versions.is_empty() {
10651            len += 1;
10652        }
10653        if !self.workers.is_empty() {
10654            len += 1;
10655        }
10656        let mut struct_ser = serializer.serialize_struct("hummock.PinnedVersionsSummary", len)?;
10657        if !self.pinned_versions.is_empty() {
10658            struct_ser.serialize_field("pinnedVersions", &self.pinned_versions)?;
10659        }
10660        if !self.workers.is_empty() {
10661            struct_ser.serialize_field("workers", &self.workers)?;
10662        }
10663        struct_ser.end()
10664    }
10665}
10666impl<'de> serde::Deserialize<'de> for PinnedVersionsSummary {
10667    #[allow(deprecated)]
10668    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10669    where
10670        D: serde::Deserializer<'de>,
10671    {
10672        const FIELDS: &[&str] = &[
10673            "pinned_versions",
10674            "pinnedVersions",
10675            "workers",
10676        ];
10677
10678        #[allow(clippy::enum_variant_names)]
10679        enum GeneratedField {
10680            PinnedVersions,
10681            Workers,
10682        }
10683        impl<'de> serde::Deserialize<'de> for GeneratedField {
10684            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10685            where
10686                D: serde::Deserializer<'de>,
10687            {
10688                struct GeneratedVisitor;
10689
10690                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10691                    type Value = GeneratedField;
10692
10693                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10694                        write!(formatter, "expected one of: {:?}", &FIELDS)
10695                    }
10696
10697                    #[allow(unused_variables)]
10698                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10699                    where
10700                        E: serde::de::Error,
10701                    {
10702                        match value {
10703                            "pinnedVersions" | "pinned_versions" => Ok(GeneratedField::PinnedVersions),
10704                            "workers" => Ok(GeneratedField::Workers),
10705                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10706                        }
10707                    }
10708                }
10709                deserializer.deserialize_identifier(GeneratedVisitor)
10710            }
10711        }
10712        struct GeneratedVisitor;
10713        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10714            type Value = PinnedVersionsSummary;
10715
10716            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10717                formatter.write_str("struct hummock.PinnedVersionsSummary")
10718            }
10719
10720            fn visit_map<V>(self, mut map_: V) -> std::result::Result<PinnedVersionsSummary, V::Error>
10721                where
10722                    V: serde::de::MapAccess<'de>,
10723            {
10724                let mut pinned_versions__ = None;
10725                let mut workers__ = None;
10726                while let Some(k) = map_.next_key()? {
10727                    match k {
10728                        GeneratedField::PinnedVersions => {
10729                            if pinned_versions__.is_some() {
10730                                return Err(serde::de::Error::duplicate_field("pinnedVersions"));
10731                            }
10732                            pinned_versions__ = Some(map_.next_value()?);
10733                        }
10734                        GeneratedField::Workers => {
10735                            if workers__.is_some() {
10736                                return Err(serde::de::Error::duplicate_field("workers"));
10737                            }
10738                            workers__ = Some(
10739                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
10740                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
10741                            );
10742                        }
10743                    }
10744                }
10745                Ok(PinnedVersionsSummary {
10746                    pinned_versions: pinned_versions__.unwrap_or_default(),
10747                    workers: workers__.unwrap_or_default(),
10748                })
10749            }
10750        }
10751        deserializer.deserialize_struct("hummock.PinnedVersionsSummary", FIELDS, GeneratedVisitor)
10752    }
10753}
10754impl serde::Serialize for ReplayVersionDeltaRequest {
10755    #[allow(deprecated)]
10756    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10757    where
10758        S: serde::Serializer,
10759    {
10760        use serde::ser::SerializeStruct;
10761        let mut len = 0;
10762        if self.version_delta.is_some() {
10763            len += 1;
10764        }
10765        let mut struct_ser = serializer.serialize_struct("hummock.ReplayVersionDeltaRequest", len)?;
10766        if let Some(v) = self.version_delta.as_ref() {
10767            struct_ser.serialize_field("versionDelta", v)?;
10768        }
10769        struct_ser.end()
10770    }
10771}
10772impl<'de> serde::Deserialize<'de> for ReplayVersionDeltaRequest {
10773    #[allow(deprecated)]
10774    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10775    where
10776        D: serde::Deserializer<'de>,
10777    {
10778        const FIELDS: &[&str] = &[
10779            "version_delta",
10780            "versionDelta",
10781        ];
10782
10783        #[allow(clippy::enum_variant_names)]
10784        enum GeneratedField {
10785            VersionDelta,
10786        }
10787        impl<'de> serde::Deserialize<'de> for GeneratedField {
10788            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10789            where
10790                D: serde::Deserializer<'de>,
10791            {
10792                struct GeneratedVisitor;
10793
10794                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10795                    type Value = GeneratedField;
10796
10797                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10798                        write!(formatter, "expected one of: {:?}", &FIELDS)
10799                    }
10800
10801                    #[allow(unused_variables)]
10802                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10803                    where
10804                        E: serde::de::Error,
10805                    {
10806                        match value {
10807                            "versionDelta" | "version_delta" => Ok(GeneratedField::VersionDelta),
10808                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10809                        }
10810                    }
10811                }
10812                deserializer.deserialize_identifier(GeneratedVisitor)
10813            }
10814        }
10815        struct GeneratedVisitor;
10816        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10817            type Value = ReplayVersionDeltaRequest;
10818
10819            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10820                formatter.write_str("struct hummock.ReplayVersionDeltaRequest")
10821            }
10822
10823            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplayVersionDeltaRequest, V::Error>
10824                where
10825                    V: serde::de::MapAccess<'de>,
10826            {
10827                let mut version_delta__ = None;
10828                while let Some(k) = map_.next_key()? {
10829                    match k {
10830                        GeneratedField::VersionDelta => {
10831                            if version_delta__.is_some() {
10832                                return Err(serde::de::Error::duplicate_field("versionDelta"));
10833                            }
10834                            version_delta__ = map_.next_value()?;
10835                        }
10836                    }
10837                }
10838                Ok(ReplayVersionDeltaRequest {
10839                    version_delta: version_delta__,
10840                })
10841            }
10842        }
10843        deserializer.deserialize_struct("hummock.ReplayVersionDeltaRequest", FIELDS, GeneratedVisitor)
10844    }
10845}
10846impl serde::Serialize for ReplayVersionDeltaResponse {
10847    #[allow(deprecated)]
10848    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10849    where
10850        S: serde::Serializer,
10851    {
10852        use serde::ser::SerializeStruct;
10853        let mut len = 0;
10854        if self.version.is_some() {
10855            len += 1;
10856        }
10857        if !self.modified_compaction_groups.is_empty() {
10858            len += 1;
10859        }
10860        let mut struct_ser = serializer.serialize_struct("hummock.ReplayVersionDeltaResponse", len)?;
10861        if let Some(v) = self.version.as_ref() {
10862            struct_ser.serialize_field("version", v)?;
10863        }
10864        if !self.modified_compaction_groups.is_empty() {
10865            struct_ser.serialize_field("modifiedCompactionGroups", &self.modified_compaction_groups.iter().map(ToString::to_string).collect::<Vec<_>>())?;
10866        }
10867        struct_ser.end()
10868    }
10869}
10870impl<'de> serde::Deserialize<'de> for ReplayVersionDeltaResponse {
10871    #[allow(deprecated)]
10872    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10873    where
10874        D: serde::Deserializer<'de>,
10875    {
10876        const FIELDS: &[&str] = &[
10877            "version",
10878            "modified_compaction_groups",
10879            "modifiedCompactionGroups",
10880        ];
10881
10882        #[allow(clippy::enum_variant_names)]
10883        enum GeneratedField {
10884            Version,
10885            ModifiedCompactionGroups,
10886        }
10887        impl<'de> serde::Deserialize<'de> for GeneratedField {
10888            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10889            where
10890                D: serde::Deserializer<'de>,
10891            {
10892                struct GeneratedVisitor;
10893
10894                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10895                    type Value = GeneratedField;
10896
10897                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10898                        write!(formatter, "expected one of: {:?}", &FIELDS)
10899                    }
10900
10901                    #[allow(unused_variables)]
10902                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10903                    where
10904                        E: serde::de::Error,
10905                    {
10906                        match value {
10907                            "version" => Ok(GeneratedField::Version),
10908                            "modifiedCompactionGroups" | "modified_compaction_groups" => Ok(GeneratedField::ModifiedCompactionGroups),
10909                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10910                        }
10911                    }
10912                }
10913                deserializer.deserialize_identifier(GeneratedVisitor)
10914            }
10915        }
10916        struct GeneratedVisitor;
10917        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10918            type Value = ReplayVersionDeltaResponse;
10919
10920            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10921                formatter.write_str("struct hummock.ReplayVersionDeltaResponse")
10922            }
10923
10924            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplayVersionDeltaResponse, V::Error>
10925                where
10926                    V: serde::de::MapAccess<'de>,
10927            {
10928                let mut version__ = None;
10929                let mut modified_compaction_groups__ = None;
10930                while let Some(k) = map_.next_key()? {
10931                    match k {
10932                        GeneratedField::Version => {
10933                            if version__.is_some() {
10934                                return Err(serde::de::Error::duplicate_field("version"));
10935                            }
10936                            version__ = map_.next_value()?;
10937                        }
10938                        GeneratedField::ModifiedCompactionGroups => {
10939                            if modified_compaction_groups__.is_some() {
10940                                return Err(serde::de::Error::duplicate_field("modifiedCompactionGroups"));
10941                            }
10942                            modified_compaction_groups__ = 
10943                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10944                                    .into_iter().map(|x| x.0).collect())
10945                            ;
10946                        }
10947                    }
10948                }
10949                Ok(ReplayVersionDeltaResponse {
10950                    version: version__,
10951                    modified_compaction_groups: modified_compaction_groups__.unwrap_or_default(),
10952                })
10953            }
10954        }
10955        deserializer.deserialize_struct("hummock.ReplayVersionDeltaResponse", FIELDS, GeneratedVisitor)
10956    }
10957}
10958impl serde::Serialize for ReportCompactionTaskRequest {
10959    #[allow(deprecated)]
10960    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10961    where
10962        S: serde::Serializer,
10963    {
10964        use serde::ser::SerializeStruct;
10965        let mut len = 0;
10966        if self.event.is_some() {
10967            len += 1;
10968        }
10969        let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskRequest", len)?;
10970        if let Some(v) = self.event.as_ref() {
10971            match v {
10972                report_compaction_task_request::Event::ReportTask(v) => {
10973                    struct_ser.serialize_field("reportTask", v)?;
10974                }
10975                report_compaction_task_request::Event::HeartBeat(v) => {
10976                    struct_ser.serialize_field("heartBeat", v)?;
10977                }
10978            }
10979        }
10980        struct_ser.end()
10981    }
10982}
10983impl<'de> serde::Deserialize<'de> for ReportCompactionTaskRequest {
10984    #[allow(deprecated)]
10985    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10986    where
10987        D: serde::Deserializer<'de>,
10988    {
10989        const FIELDS: &[&str] = &[
10990            "report_task",
10991            "reportTask",
10992            "heart_beat",
10993            "heartBeat",
10994        ];
10995
10996        #[allow(clippy::enum_variant_names)]
10997        enum GeneratedField {
10998            ReportTask,
10999            HeartBeat,
11000        }
11001        impl<'de> serde::Deserialize<'de> for GeneratedField {
11002            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11003            where
11004                D: serde::Deserializer<'de>,
11005            {
11006                struct GeneratedVisitor;
11007
11008                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11009                    type Value = GeneratedField;
11010
11011                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11012                        write!(formatter, "expected one of: {:?}", &FIELDS)
11013                    }
11014
11015                    #[allow(unused_variables)]
11016                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11017                    where
11018                        E: serde::de::Error,
11019                    {
11020                        match value {
11021                            "reportTask" | "report_task" => Ok(GeneratedField::ReportTask),
11022                            "heartBeat" | "heart_beat" => Ok(GeneratedField::HeartBeat),
11023                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11024                        }
11025                    }
11026                }
11027                deserializer.deserialize_identifier(GeneratedVisitor)
11028            }
11029        }
11030        struct GeneratedVisitor;
11031        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11032            type Value = ReportCompactionTaskRequest;
11033
11034            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11035                formatter.write_str("struct hummock.ReportCompactionTaskRequest")
11036            }
11037
11038            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReportCompactionTaskRequest, V::Error>
11039                where
11040                    V: serde::de::MapAccess<'de>,
11041            {
11042                let mut event__ = None;
11043                while let Some(k) = map_.next_key()? {
11044                    match k {
11045                        GeneratedField::ReportTask => {
11046                            if event__.is_some() {
11047                                return Err(serde::de::Error::duplicate_field("reportTask"));
11048                            }
11049                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(report_compaction_task_request::Event::ReportTask)
11050;
11051                        }
11052                        GeneratedField::HeartBeat => {
11053                            if event__.is_some() {
11054                                return Err(serde::de::Error::duplicate_field("heartBeat"));
11055                            }
11056                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(report_compaction_task_request::Event::HeartBeat)
11057;
11058                        }
11059                    }
11060                }
11061                Ok(ReportCompactionTaskRequest {
11062                    event: event__,
11063                })
11064            }
11065        }
11066        deserializer.deserialize_struct("hummock.ReportCompactionTaskRequest", FIELDS, GeneratedVisitor)
11067    }
11068}
11069impl serde::Serialize for report_compaction_task_request::HeartBeat {
11070    #[allow(deprecated)]
11071    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11072    where
11073        S: serde::Serializer,
11074    {
11075        use serde::ser::SerializeStruct;
11076        let mut len = 0;
11077        if !self.progress.is_empty() {
11078            len += 1;
11079        }
11080        let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskRequest.HeartBeat", len)?;
11081        if !self.progress.is_empty() {
11082            struct_ser.serialize_field("progress", &self.progress)?;
11083        }
11084        struct_ser.end()
11085    }
11086}
11087impl<'de> serde::Deserialize<'de> for report_compaction_task_request::HeartBeat {
11088    #[allow(deprecated)]
11089    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11090    where
11091        D: serde::Deserializer<'de>,
11092    {
11093        const FIELDS: &[&str] = &[
11094            "progress",
11095        ];
11096
11097        #[allow(clippy::enum_variant_names)]
11098        enum GeneratedField {
11099            Progress,
11100        }
11101        impl<'de> serde::Deserialize<'de> for GeneratedField {
11102            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11103            where
11104                D: serde::Deserializer<'de>,
11105            {
11106                struct GeneratedVisitor;
11107
11108                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11109                    type Value = GeneratedField;
11110
11111                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11112                        write!(formatter, "expected one of: {:?}", &FIELDS)
11113                    }
11114
11115                    #[allow(unused_variables)]
11116                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11117                    where
11118                        E: serde::de::Error,
11119                    {
11120                        match value {
11121                            "progress" => Ok(GeneratedField::Progress),
11122                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11123                        }
11124                    }
11125                }
11126                deserializer.deserialize_identifier(GeneratedVisitor)
11127            }
11128        }
11129        struct GeneratedVisitor;
11130        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11131            type Value = report_compaction_task_request::HeartBeat;
11132
11133            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11134                formatter.write_str("struct hummock.ReportCompactionTaskRequest.HeartBeat")
11135            }
11136
11137            fn visit_map<V>(self, mut map_: V) -> std::result::Result<report_compaction_task_request::HeartBeat, V::Error>
11138                where
11139                    V: serde::de::MapAccess<'de>,
11140            {
11141                let mut progress__ = None;
11142                while let Some(k) = map_.next_key()? {
11143                    match k {
11144                        GeneratedField::Progress => {
11145                            if progress__.is_some() {
11146                                return Err(serde::de::Error::duplicate_field("progress"));
11147                            }
11148                            progress__ = Some(map_.next_value()?);
11149                        }
11150                    }
11151                }
11152                Ok(report_compaction_task_request::HeartBeat {
11153                    progress: progress__.unwrap_or_default(),
11154                })
11155            }
11156        }
11157        deserializer.deserialize_struct("hummock.ReportCompactionTaskRequest.HeartBeat", FIELDS, GeneratedVisitor)
11158    }
11159}
11160impl serde::Serialize for report_compaction_task_request::ReportTask {
11161    #[allow(deprecated)]
11162    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11163    where
11164        S: serde::Serializer,
11165    {
11166        use serde::ser::SerializeStruct;
11167        let mut len = 0;
11168        if self.compact_task.is_some() {
11169            len += 1;
11170        }
11171        if !self.table_stats_change.is_empty() {
11172            len += 1;
11173        }
11174        if !self.object_timestamps.is_empty() {
11175            len += 1;
11176        }
11177        let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskRequest.ReportTask", len)?;
11178        if let Some(v) = self.compact_task.as_ref() {
11179            struct_ser.serialize_field("compactTask", v)?;
11180        }
11181        if !self.table_stats_change.is_empty() {
11182            struct_ser.serialize_field("tableStatsChange", &self.table_stats_change)?;
11183        }
11184        if !self.object_timestamps.is_empty() {
11185            let v: std::collections::HashMap<_, _> = self.object_timestamps.iter()
11186                .map(|(k, v)| (k, v.to_string())).collect();
11187            struct_ser.serialize_field("objectTimestamps", &v)?;
11188        }
11189        struct_ser.end()
11190    }
11191}
11192impl<'de> serde::Deserialize<'de> for report_compaction_task_request::ReportTask {
11193    #[allow(deprecated)]
11194    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11195    where
11196        D: serde::Deserializer<'de>,
11197    {
11198        const FIELDS: &[&str] = &[
11199            "compact_task",
11200            "compactTask",
11201            "table_stats_change",
11202            "tableStatsChange",
11203            "object_timestamps",
11204            "objectTimestamps",
11205        ];
11206
11207        #[allow(clippy::enum_variant_names)]
11208        enum GeneratedField {
11209            CompactTask,
11210            TableStatsChange,
11211            ObjectTimestamps,
11212        }
11213        impl<'de> serde::Deserialize<'de> for GeneratedField {
11214            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11215            where
11216                D: serde::Deserializer<'de>,
11217            {
11218                struct GeneratedVisitor;
11219
11220                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11221                    type Value = GeneratedField;
11222
11223                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11224                        write!(formatter, "expected one of: {:?}", &FIELDS)
11225                    }
11226
11227                    #[allow(unused_variables)]
11228                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11229                    where
11230                        E: serde::de::Error,
11231                    {
11232                        match value {
11233                            "compactTask" | "compact_task" => Ok(GeneratedField::CompactTask),
11234                            "tableStatsChange" | "table_stats_change" => Ok(GeneratedField::TableStatsChange),
11235                            "objectTimestamps" | "object_timestamps" => Ok(GeneratedField::ObjectTimestamps),
11236                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11237                        }
11238                    }
11239                }
11240                deserializer.deserialize_identifier(GeneratedVisitor)
11241            }
11242        }
11243        struct GeneratedVisitor;
11244        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11245            type Value = report_compaction_task_request::ReportTask;
11246
11247            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11248                formatter.write_str("struct hummock.ReportCompactionTaskRequest.ReportTask")
11249            }
11250
11251            fn visit_map<V>(self, mut map_: V) -> std::result::Result<report_compaction_task_request::ReportTask, V::Error>
11252                where
11253                    V: serde::de::MapAccess<'de>,
11254            {
11255                let mut compact_task__ = None;
11256                let mut table_stats_change__ = None;
11257                let mut object_timestamps__ = None;
11258                while let Some(k) = map_.next_key()? {
11259                    match k {
11260                        GeneratedField::CompactTask => {
11261                            if compact_task__.is_some() {
11262                                return Err(serde::de::Error::duplicate_field("compactTask"));
11263                            }
11264                            compact_task__ = map_.next_value()?;
11265                        }
11266                        GeneratedField::TableStatsChange => {
11267                            if table_stats_change__.is_some() {
11268                                return Err(serde::de::Error::duplicate_field("tableStatsChange"));
11269                            }
11270                            table_stats_change__ = Some(
11271                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
11272                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
11273                            );
11274                        }
11275                        GeneratedField::ObjectTimestamps => {
11276                            if object_timestamps__.is_some() {
11277                                return Err(serde::de::Error::duplicate_field("objectTimestamps"));
11278                            }
11279                            object_timestamps__ = Some(
11280                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
11281                                    .into_iter().map(|(k,v)| (k.0, v.0)).collect()
11282                            );
11283                        }
11284                    }
11285                }
11286                Ok(report_compaction_task_request::ReportTask {
11287                    compact_task: compact_task__,
11288                    table_stats_change: table_stats_change__.unwrap_or_default(),
11289                    object_timestamps: object_timestamps__.unwrap_or_default(),
11290                })
11291            }
11292        }
11293        deserializer.deserialize_struct("hummock.ReportCompactionTaskRequest.ReportTask", FIELDS, GeneratedVisitor)
11294    }
11295}
11296impl serde::Serialize for ReportCompactionTaskResponse {
11297    #[allow(deprecated)]
11298    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11299    where
11300        S: serde::Serializer,
11301    {
11302        use serde::ser::SerializeStruct;
11303        let mut len = 0;
11304        if self.status.is_some() {
11305            len += 1;
11306        }
11307        let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskResponse", len)?;
11308        if let Some(v) = self.status.as_ref() {
11309            struct_ser.serialize_field("status", v)?;
11310        }
11311        struct_ser.end()
11312    }
11313}
11314impl<'de> serde::Deserialize<'de> for ReportCompactionTaskResponse {
11315    #[allow(deprecated)]
11316    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11317    where
11318        D: serde::Deserializer<'de>,
11319    {
11320        const FIELDS: &[&str] = &[
11321            "status",
11322        ];
11323
11324        #[allow(clippy::enum_variant_names)]
11325        enum GeneratedField {
11326            Status,
11327        }
11328        impl<'de> serde::Deserialize<'de> for GeneratedField {
11329            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11330            where
11331                D: serde::Deserializer<'de>,
11332            {
11333                struct GeneratedVisitor;
11334
11335                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11336                    type Value = GeneratedField;
11337
11338                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11339                        write!(formatter, "expected one of: {:?}", &FIELDS)
11340                    }
11341
11342                    #[allow(unused_variables)]
11343                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11344                    where
11345                        E: serde::de::Error,
11346                    {
11347                        match value {
11348                            "status" => Ok(GeneratedField::Status),
11349                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11350                        }
11351                    }
11352                }
11353                deserializer.deserialize_identifier(GeneratedVisitor)
11354            }
11355        }
11356        struct GeneratedVisitor;
11357        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11358            type Value = ReportCompactionTaskResponse;
11359
11360            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11361                formatter.write_str("struct hummock.ReportCompactionTaskResponse")
11362            }
11363
11364            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReportCompactionTaskResponse, V::Error>
11365                where
11366                    V: serde::de::MapAccess<'de>,
11367            {
11368                let mut status__ = None;
11369                while let Some(k) = map_.next_key()? {
11370                    match k {
11371                        GeneratedField::Status => {
11372                            if status__.is_some() {
11373                                return Err(serde::de::Error::duplicate_field("status"));
11374                            }
11375                            status__ = map_.next_value()?;
11376                        }
11377                    }
11378                }
11379                Ok(ReportCompactionTaskResponse {
11380                    status: status__,
11381                })
11382            }
11383        }
11384        deserializer.deserialize_struct("hummock.ReportCompactionTaskResponse", FIELDS, GeneratedVisitor)
11385    }
11386}
11387impl serde::Serialize for RiseCtlGetCheckpointVersionRequest {
11388    #[allow(deprecated)]
11389    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11390    where
11391        S: serde::Serializer,
11392    {
11393        use serde::ser::SerializeStruct;
11394        let len = 0;
11395        let struct_ser = serializer.serialize_struct("hummock.RiseCtlGetCheckpointVersionRequest", len)?;
11396        struct_ser.end()
11397    }
11398}
11399impl<'de> serde::Deserialize<'de> for RiseCtlGetCheckpointVersionRequest {
11400    #[allow(deprecated)]
11401    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11402    where
11403        D: serde::Deserializer<'de>,
11404    {
11405        const FIELDS: &[&str] = &[
11406        ];
11407
11408        #[allow(clippy::enum_variant_names)]
11409        enum GeneratedField {
11410        }
11411        impl<'de> serde::Deserialize<'de> for GeneratedField {
11412            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11413            where
11414                D: serde::Deserializer<'de>,
11415            {
11416                struct GeneratedVisitor;
11417
11418                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11419                    type Value = GeneratedField;
11420
11421                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11422                        write!(formatter, "expected one of: {:?}", &FIELDS)
11423                    }
11424
11425                    #[allow(unused_variables)]
11426                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11427                    where
11428                        E: serde::de::Error,
11429                    {
11430                            Err(serde::de::Error::unknown_field(value, FIELDS))
11431                    }
11432                }
11433                deserializer.deserialize_identifier(GeneratedVisitor)
11434            }
11435        }
11436        struct GeneratedVisitor;
11437        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11438            type Value = RiseCtlGetCheckpointVersionRequest;
11439
11440            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11441                formatter.write_str("struct hummock.RiseCtlGetCheckpointVersionRequest")
11442            }
11443
11444            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetCheckpointVersionRequest, V::Error>
11445                where
11446                    V: serde::de::MapAccess<'de>,
11447            {
11448                while map_.next_key::<GeneratedField>()?.is_some() {
11449                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11450                }
11451                Ok(RiseCtlGetCheckpointVersionRequest {
11452                })
11453            }
11454        }
11455        deserializer.deserialize_struct("hummock.RiseCtlGetCheckpointVersionRequest", FIELDS, GeneratedVisitor)
11456    }
11457}
11458impl serde::Serialize for RiseCtlGetCheckpointVersionResponse {
11459    #[allow(deprecated)]
11460    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11461    where
11462        S: serde::Serializer,
11463    {
11464        use serde::ser::SerializeStruct;
11465        let mut len = 0;
11466        if self.checkpoint_version.is_some() {
11467            len += 1;
11468        }
11469        let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlGetCheckpointVersionResponse", len)?;
11470        if let Some(v) = self.checkpoint_version.as_ref() {
11471            struct_ser.serialize_field("checkpointVersion", v)?;
11472        }
11473        struct_ser.end()
11474    }
11475}
11476impl<'de> serde::Deserialize<'de> for RiseCtlGetCheckpointVersionResponse {
11477    #[allow(deprecated)]
11478    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11479    where
11480        D: serde::Deserializer<'de>,
11481    {
11482        const FIELDS: &[&str] = &[
11483            "checkpoint_version",
11484            "checkpointVersion",
11485        ];
11486
11487        #[allow(clippy::enum_variant_names)]
11488        enum GeneratedField {
11489            CheckpointVersion,
11490        }
11491        impl<'de> serde::Deserialize<'de> for GeneratedField {
11492            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11493            where
11494                D: serde::Deserializer<'de>,
11495            {
11496                struct GeneratedVisitor;
11497
11498                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11499                    type Value = GeneratedField;
11500
11501                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11502                        write!(formatter, "expected one of: {:?}", &FIELDS)
11503                    }
11504
11505                    #[allow(unused_variables)]
11506                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11507                    where
11508                        E: serde::de::Error,
11509                    {
11510                        match value {
11511                            "checkpointVersion" | "checkpoint_version" => Ok(GeneratedField::CheckpointVersion),
11512                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11513                        }
11514                    }
11515                }
11516                deserializer.deserialize_identifier(GeneratedVisitor)
11517            }
11518        }
11519        struct GeneratedVisitor;
11520        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11521            type Value = RiseCtlGetCheckpointVersionResponse;
11522
11523            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11524                formatter.write_str("struct hummock.RiseCtlGetCheckpointVersionResponse")
11525            }
11526
11527            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetCheckpointVersionResponse, V::Error>
11528                where
11529                    V: serde::de::MapAccess<'de>,
11530            {
11531                let mut checkpoint_version__ = None;
11532                while let Some(k) = map_.next_key()? {
11533                    match k {
11534                        GeneratedField::CheckpointVersion => {
11535                            if checkpoint_version__.is_some() {
11536                                return Err(serde::de::Error::duplicate_field("checkpointVersion"));
11537                            }
11538                            checkpoint_version__ = map_.next_value()?;
11539                        }
11540                    }
11541                }
11542                Ok(RiseCtlGetCheckpointVersionResponse {
11543                    checkpoint_version: checkpoint_version__,
11544                })
11545            }
11546        }
11547        deserializer.deserialize_struct("hummock.RiseCtlGetCheckpointVersionResponse", FIELDS, GeneratedVisitor)
11548    }
11549}
11550impl serde::Serialize for RiseCtlGetPinnedVersionsSummaryRequest {
11551    #[allow(deprecated)]
11552    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11553    where
11554        S: serde::Serializer,
11555    {
11556        use serde::ser::SerializeStruct;
11557        let len = 0;
11558        let struct_ser = serializer.serialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryRequest", len)?;
11559        struct_ser.end()
11560    }
11561}
11562impl<'de> serde::Deserialize<'de> for RiseCtlGetPinnedVersionsSummaryRequest {
11563    #[allow(deprecated)]
11564    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11565    where
11566        D: serde::Deserializer<'de>,
11567    {
11568        const FIELDS: &[&str] = &[
11569        ];
11570
11571        #[allow(clippy::enum_variant_names)]
11572        enum GeneratedField {
11573        }
11574        impl<'de> serde::Deserialize<'de> for GeneratedField {
11575            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11576            where
11577                D: serde::Deserializer<'de>,
11578            {
11579                struct GeneratedVisitor;
11580
11581                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11582                    type Value = GeneratedField;
11583
11584                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11585                        write!(formatter, "expected one of: {:?}", &FIELDS)
11586                    }
11587
11588                    #[allow(unused_variables)]
11589                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11590                    where
11591                        E: serde::de::Error,
11592                    {
11593                            Err(serde::de::Error::unknown_field(value, FIELDS))
11594                    }
11595                }
11596                deserializer.deserialize_identifier(GeneratedVisitor)
11597            }
11598        }
11599        struct GeneratedVisitor;
11600        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11601            type Value = RiseCtlGetPinnedVersionsSummaryRequest;
11602
11603            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11604                formatter.write_str("struct hummock.RiseCtlGetPinnedVersionsSummaryRequest")
11605            }
11606
11607            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetPinnedVersionsSummaryRequest, V::Error>
11608                where
11609                    V: serde::de::MapAccess<'de>,
11610            {
11611                while map_.next_key::<GeneratedField>()?.is_some() {
11612                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11613                }
11614                Ok(RiseCtlGetPinnedVersionsSummaryRequest {
11615                })
11616            }
11617        }
11618        deserializer.deserialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryRequest", FIELDS, GeneratedVisitor)
11619    }
11620}
11621impl serde::Serialize for RiseCtlGetPinnedVersionsSummaryResponse {
11622    #[allow(deprecated)]
11623    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11624    where
11625        S: serde::Serializer,
11626    {
11627        use serde::ser::SerializeStruct;
11628        let mut len = 0;
11629        if self.summary.is_some() {
11630            len += 1;
11631        }
11632        let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryResponse", len)?;
11633        if let Some(v) = self.summary.as_ref() {
11634            struct_ser.serialize_field("summary", v)?;
11635        }
11636        struct_ser.end()
11637    }
11638}
11639impl<'de> serde::Deserialize<'de> for RiseCtlGetPinnedVersionsSummaryResponse {
11640    #[allow(deprecated)]
11641    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11642    where
11643        D: serde::Deserializer<'de>,
11644    {
11645        const FIELDS: &[&str] = &[
11646            "summary",
11647        ];
11648
11649        #[allow(clippy::enum_variant_names)]
11650        enum GeneratedField {
11651            Summary,
11652        }
11653        impl<'de> serde::Deserialize<'de> for GeneratedField {
11654            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11655            where
11656                D: serde::Deserializer<'de>,
11657            {
11658                struct GeneratedVisitor;
11659
11660                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11661                    type Value = GeneratedField;
11662
11663                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11664                        write!(formatter, "expected one of: {:?}", &FIELDS)
11665                    }
11666
11667                    #[allow(unused_variables)]
11668                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11669                    where
11670                        E: serde::de::Error,
11671                    {
11672                        match value {
11673                            "summary" => Ok(GeneratedField::Summary),
11674                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11675                        }
11676                    }
11677                }
11678                deserializer.deserialize_identifier(GeneratedVisitor)
11679            }
11680        }
11681        struct GeneratedVisitor;
11682        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11683            type Value = RiseCtlGetPinnedVersionsSummaryResponse;
11684
11685            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11686                formatter.write_str("struct hummock.RiseCtlGetPinnedVersionsSummaryResponse")
11687            }
11688
11689            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetPinnedVersionsSummaryResponse, V::Error>
11690                where
11691                    V: serde::de::MapAccess<'de>,
11692            {
11693                let mut summary__ = None;
11694                while let Some(k) = map_.next_key()? {
11695                    match k {
11696                        GeneratedField::Summary => {
11697                            if summary__.is_some() {
11698                                return Err(serde::de::Error::duplicate_field("summary"));
11699                            }
11700                            summary__ = map_.next_value()?;
11701                        }
11702                    }
11703                }
11704                Ok(RiseCtlGetPinnedVersionsSummaryResponse {
11705                    summary: summary__,
11706                })
11707            }
11708        }
11709        deserializer.deserialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryResponse", FIELDS, GeneratedVisitor)
11710    }
11711}
11712impl serde::Serialize for RiseCtlListCompactionGroupRequest {
11713    #[allow(deprecated)]
11714    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11715    where
11716        S: serde::Serializer,
11717    {
11718        use serde::ser::SerializeStruct;
11719        let len = 0;
11720        let struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionGroupRequest", len)?;
11721        struct_ser.end()
11722    }
11723}
11724impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionGroupRequest {
11725    #[allow(deprecated)]
11726    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11727    where
11728        D: serde::Deserializer<'de>,
11729    {
11730        const FIELDS: &[&str] = &[
11731        ];
11732
11733        #[allow(clippy::enum_variant_names)]
11734        enum GeneratedField {
11735        }
11736        impl<'de> serde::Deserialize<'de> for GeneratedField {
11737            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11738            where
11739                D: serde::Deserializer<'de>,
11740            {
11741                struct GeneratedVisitor;
11742
11743                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11744                    type Value = GeneratedField;
11745
11746                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11747                        write!(formatter, "expected one of: {:?}", &FIELDS)
11748                    }
11749
11750                    #[allow(unused_variables)]
11751                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11752                    where
11753                        E: serde::de::Error,
11754                    {
11755                            Err(serde::de::Error::unknown_field(value, FIELDS))
11756                    }
11757                }
11758                deserializer.deserialize_identifier(GeneratedVisitor)
11759            }
11760        }
11761        struct GeneratedVisitor;
11762        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11763            type Value = RiseCtlListCompactionGroupRequest;
11764
11765            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11766                formatter.write_str("struct hummock.RiseCtlListCompactionGroupRequest")
11767            }
11768
11769            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionGroupRequest, V::Error>
11770                where
11771                    V: serde::de::MapAccess<'de>,
11772            {
11773                while map_.next_key::<GeneratedField>()?.is_some() {
11774                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11775                }
11776                Ok(RiseCtlListCompactionGroupRequest {
11777                })
11778            }
11779        }
11780        deserializer.deserialize_struct("hummock.RiseCtlListCompactionGroupRequest", FIELDS, GeneratedVisitor)
11781    }
11782}
11783impl serde::Serialize for RiseCtlListCompactionGroupResponse {
11784    #[allow(deprecated)]
11785    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11786    where
11787        S: serde::Serializer,
11788    {
11789        use serde::ser::SerializeStruct;
11790        let mut len = 0;
11791        if self.status.is_some() {
11792            len += 1;
11793        }
11794        if !self.compaction_groups.is_empty() {
11795            len += 1;
11796        }
11797        let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionGroupResponse", len)?;
11798        if let Some(v) = self.status.as_ref() {
11799            struct_ser.serialize_field("status", v)?;
11800        }
11801        if !self.compaction_groups.is_empty() {
11802            struct_ser.serialize_field("compactionGroups", &self.compaction_groups)?;
11803        }
11804        struct_ser.end()
11805    }
11806}
11807impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionGroupResponse {
11808    #[allow(deprecated)]
11809    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11810    where
11811        D: serde::Deserializer<'de>,
11812    {
11813        const FIELDS: &[&str] = &[
11814            "status",
11815            "compaction_groups",
11816            "compactionGroups",
11817        ];
11818
11819        #[allow(clippy::enum_variant_names)]
11820        enum GeneratedField {
11821            Status,
11822            CompactionGroups,
11823        }
11824        impl<'de> serde::Deserialize<'de> for GeneratedField {
11825            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11826            where
11827                D: serde::Deserializer<'de>,
11828            {
11829                struct GeneratedVisitor;
11830
11831                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11832                    type Value = GeneratedField;
11833
11834                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11835                        write!(formatter, "expected one of: {:?}", &FIELDS)
11836                    }
11837
11838                    #[allow(unused_variables)]
11839                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11840                    where
11841                        E: serde::de::Error,
11842                    {
11843                        match value {
11844                            "status" => Ok(GeneratedField::Status),
11845                            "compactionGroups" | "compaction_groups" => Ok(GeneratedField::CompactionGroups),
11846                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11847                        }
11848                    }
11849                }
11850                deserializer.deserialize_identifier(GeneratedVisitor)
11851            }
11852        }
11853        struct GeneratedVisitor;
11854        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11855            type Value = RiseCtlListCompactionGroupResponse;
11856
11857            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11858                formatter.write_str("struct hummock.RiseCtlListCompactionGroupResponse")
11859            }
11860
11861            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionGroupResponse, V::Error>
11862                where
11863                    V: serde::de::MapAccess<'de>,
11864            {
11865                let mut status__ = None;
11866                let mut compaction_groups__ = None;
11867                while let Some(k) = map_.next_key()? {
11868                    match k {
11869                        GeneratedField::Status => {
11870                            if status__.is_some() {
11871                                return Err(serde::de::Error::duplicate_field("status"));
11872                            }
11873                            status__ = map_.next_value()?;
11874                        }
11875                        GeneratedField::CompactionGroups => {
11876                            if compaction_groups__.is_some() {
11877                                return Err(serde::de::Error::duplicate_field("compactionGroups"));
11878                            }
11879                            compaction_groups__ = Some(map_.next_value()?);
11880                        }
11881                    }
11882                }
11883                Ok(RiseCtlListCompactionGroupResponse {
11884                    status: status__,
11885                    compaction_groups: compaction_groups__.unwrap_or_default(),
11886                })
11887            }
11888        }
11889        deserializer.deserialize_struct("hummock.RiseCtlListCompactionGroupResponse", FIELDS, GeneratedVisitor)
11890    }
11891}
11892impl serde::Serialize for RiseCtlListCompactionStatusRequest {
11893    #[allow(deprecated)]
11894    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11895    where
11896        S: serde::Serializer,
11897    {
11898        use serde::ser::SerializeStruct;
11899        let len = 0;
11900        let struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionStatusRequest", len)?;
11901        struct_ser.end()
11902    }
11903}
11904impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionStatusRequest {
11905    #[allow(deprecated)]
11906    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11907    where
11908        D: serde::Deserializer<'de>,
11909    {
11910        const FIELDS: &[&str] = &[
11911        ];
11912
11913        #[allow(clippy::enum_variant_names)]
11914        enum GeneratedField {
11915        }
11916        impl<'de> serde::Deserialize<'de> for GeneratedField {
11917            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11918            where
11919                D: serde::Deserializer<'de>,
11920            {
11921                struct GeneratedVisitor;
11922
11923                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11924                    type Value = GeneratedField;
11925
11926                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11927                        write!(formatter, "expected one of: {:?}", &FIELDS)
11928                    }
11929
11930                    #[allow(unused_variables)]
11931                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11932                    where
11933                        E: serde::de::Error,
11934                    {
11935                            Err(serde::de::Error::unknown_field(value, FIELDS))
11936                    }
11937                }
11938                deserializer.deserialize_identifier(GeneratedVisitor)
11939            }
11940        }
11941        struct GeneratedVisitor;
11942        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11943            type Value = RiseCtlListCompactionStatusRequest;
11944
11945            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11946                formatter.write_str("struct hummock.RiseCtlListCompactionStatusRequest")
11947            }
11948
11949            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionStatusRequest, V::Error>
11950                where
11951                    V: serde::de::MapAccess<'de>,
11952            {
11953                while map_.next_key::<GeneratedField>()?.is_some() {
11954                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11955                }
11956                Ok(RiseCtlListCompactionStatusRequest {
11957                })
11958            }
11959        }
11960        deserializer.deserialize_struct("hummock.RiseCtlListCompactionStatusRequest", FIELDS, GeneratedVisitor)
11961    }
11962}
11963impl serde::Serialize for RiseCtlListCompactionStatusResponse {
11964    #[allow(deprecated)]
11965    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11966    where
11967        S: serde::Serializer,
11968    {
11969        use serde::ser::SerializeStruct;
11970        let mut len = 0;
11971        if !self.compaction_statuses.is_empty() {
11972            len += 1;
11973        }
11974        if !self.task_assignment.is_empty() {
11975            len += 1;
11976        }
11977        if !self.task_progress.is_empty() {
11978            len += 1;
11979        }
11980        let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionStatusResponse", len)?;
11981        if !self.compaction_statuses.is_empty() {
11982            struct_ser.serialize_field("compactionStatuses", &self.compaction_statuses)?;
11983        }
11984        if !self.task_assignment.is_empty() {
11985            struct_ser.serialize_field("taskAssignment", &self.task_assignment)?;
11986        }
11987        if !self.task_progress.is_empty() {
11988            struct_ser.serialize_field("taskProgress", &self.task_progress)?;
11989        }
11990        struct_ser.end()
11991    }
11992}
11993impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionStatusResponse {
11994    #[allow(deprecated)]
11995    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11996    where
11997        D: serde::Deserializer<'de>,
11998    {
11999        const FIELDS: &[&str] = &[
12000            "compaction_statuses",
12001            "compactionStatuses",
12002            "task_assignment",
12003            "taskAssignment",
12004            "task_progress",
12005            "taskProgress",
12006        ];
12007
12008        #[allow(clippy::enum_variant_names)]
12009        enum GeneratedField {
12010            CompactionStatuses,
12011            TaskAssignment,
12012            TaskProgress,
12013        }
12014        impl<'de> serde::Deserialize<'de> for GeneratedField {
12015            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12016            where
12017                D: serde::Deserializer<'de>,
12018            {
12019                struct GeneratedVisitor;
12020
12021                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12022                    type Value = GeneratedField;
12023
12024                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12025                        write!(formatter, "expected one of: {:?}", &FIELDS)
12026                    }
12027
12028                    #[allow(unused_variables)]
12029                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12030                    where
12031                        E: serde::de::Error,
12032                    {
12033                        match value {
12034                            "compactionStatuses" | "compaction_statuses" => Ok(GeneratedField::CompactionStatuses),
12035                            "taskAssignment" | "task_assignment" => Ok(GeneratedField::TaskAssignment),
12036                            "taskProgress" | "task_progress" => Ok(GeneratedField::TaskProgress),
12037                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12038                        }
12039                    }
12040                }
12041                deserializer.deserialize_identifier(GeneratedVisitor)
12042            }
12043        }
12044        struct GeneratedVisitor;
12045        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12046            type Value = RiseCtlListCompactionStatusResponse;
12047
12048            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12049                formatter.write_str("struct hummock.RiseCtlListCompactionStatusResponse")
12050            }
12051
12052            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionStatusResponse, V::Error>
12053                where
12054                    V: serde::de::MapAccess<'de>,
12055            {
12056                let mut compaction_statuses__ = None;
12057                let mut task_assignment__ = None;
12058                let mut task_progress__ = None;
12059                while let Some(k) = map_.next_key()? {
12060                    match k {
12061                        GeneratedField::CompactionStatuses => {
12062                            if compaction_statuses__.is_some() {
12063                                return Err(serde::de::Error::duplicate_field("compactionStatuses"));
12064                            }
12065                            compaction_statuses__ = Some(map_.next_value()?);
12066                        }
12067                        GeneratedField::TaskAssignment => {
12068                            if task_assignment__.is_some() {
12069                                return Err(serde::de::Error::duplicate_field("taskAssignment"));
12070                            }
12071                            task_assignment__ = Some(map_.next_value()?);
12072                        }
12073                        GeneratedField::TaskProgress => {
12074                            if task_progress__.is_some() {
12075                                return Err(serde::de::Error::duplicate_field("taskProgress"));
12076                            }
12077                            task_progress__ = Some(map_.next_value()?);
12078                        }
12079                    }
12080                }
12081                Ok(RiseCtlListCompactionStatusResponse {
12082                    compaction_statuses: compaction_statuses__.unwrap_or_default(),
12083                    task_assignment: task_assignment__.unwrap_or_default(),
12084                    task_progress: task_progress__.unwrap_or_default(),
12085                })
12086            }
12087        }
12088        deserializer.deserialize_struct("hummock.RiseCtlListCompactionStatusResponse", FIELDS, GeneratedVisitor)
12089    }
12090}
12091impl serde::Serialize for RiseCtlPauseVersionCheckpointRequest {
12092    #[allow(deprecated)]
12093    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12094    where
12095        S: serde::Serializer,
12096    {
12097        use serde::ser::SerializeStruct;
12098        let len = 0;
12099        let struct_ser = serializer.serialize_struct("hummock.RiseCtlPauseVersionCheckpointRequest", len)?;
12100        struct_ser.end()
12101    }
12102}
12103impl<'de> serde::Deserialize<'de> for RiseCtlPauseVersionCheckpointRequest {
12104    #[allow(deprecated)]
12105    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12106    where
12107        D: serde::Deserializer<'de>,
12108    {
12109        const FIELDS: &[&str] = &[
12110        ];
12111
12112        #[allow(clippy::enum_variant_names)]
12113        enum GeneratedField {
12114        }
12115        impl<'de> serde::Deserialize<'de> for GeneratedField {
12116            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12117            where
12118                D: serde::Deserializer<'de>,
12119            {
12120                struct GeneratedVisitor;
12121
12122                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12123                    type Value = GeneratedField;
12124
12125                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12126                        write!(formatter, "expected one of: {:?}", &FIELDS)
12127                    }
12128
12129                    #[allow(unused_variables)]
12130                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12131                    where
12132                        E: serde::de::Error,
12133                    {
12134                            Err(serde::de::Error::unknown_field(value, FIELDS))
12135                    }
12136                }
12137                deserializer.deserialize_identifier(GeneratedVisitor)
12138            }
12139        }
12140        struct GeneratedVisitor;
12141        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12142            type Value = RiseCtlPauseVersionCheckpointRequest;
12143
12144            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12145                formatter.write_str("struct hummock.RiseCtlPauseVersionCheckpointRequest")
12146            }
12147
12148            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlPauseVersionCheckpointRequest, V::Error>
12149                where
12150                    V: serde::de::MapAccess<'de>,
12151            {
12152                while map_.next_key::<GeneratedField>()?.is_some() {
12153                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12154                }
12155                Ok(RiseCtlPauseVersionCheckpointRequest {
12156                })
12157            }
12158        }
12159        deserializer.deserialize_struct("hummock.RiseCtlPauseVersionCheckpointRequest", FIELDS, GeneratedVisitor)
12160    }
12161}
12162impl serde::Serialize for RiseCtlPauseVersionCheckpointResponse {
12163    #[allow(deprecated)]
12164    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12165    where
12166        S: serde::Serializer,
12167    {
12168        use serde::ser::SerializeStruct;
12169        let len = 0;
12170        let struct_ser = serializer.serialize_struct("hummock.RiseCtlPauseVersionCheckpointResponse", len)?;
12171        struct_ser.end()
12172    }
12173}
12174impl<'de> serde::Deserialize<'de> for RiseCtlPauseVersionCheckpointResponse {
12175    #[allow(deprecated)]
12176    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12177    where
12178        D: serde::Deserializer<'de>,
12179    {
12180        const FIELDS: &[&str] = &[
12181        ];
12182
12183        #[allow(clippy::enum_variant_names)]
12184        enum GeneratedField {
12185        }
12186        impl<'de> serde::Deserialize<'de> for GeneratedField {
12187            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12188            where
12189                D: serde::Deserializer<'de>,
12190            {
12191                struct GeneratedVisitor;
12192
12193                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12194                    type Value = GeneratedField;
12195
12196                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12197                        write!(formatter, "expected one of: {:?}", &FIELDS)
12198                    }
12199
12200                    #[allow(unused_variables)]
12201                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12202                    where
12203                        E: serde::de::Error,
12204                    {
12205                            Err(serde::de::Error::unknown_field(value, FIELDS))
12206                    }
12207                }
12208                deserializer.deserialize_identifier(GeneratedVisitor)
12209            }
12210        }
12211        struct GeneratedVisitor;
12212        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12213            type Value = RiseCtlPauseVersionCheckpointResponse;
12214
12215            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12216                formatter.write_str("struct hummock.RiseCtlPauseVersionCheckpointResponse")
12217            }
12218
12219            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlPauseVersionCheckpointResponse, V::Error>
12220                where
12221                    V: serde::de::MapAccess<'de>,
12222            {
12223                while map_.next_key::<GeneratedField>()?.is_some() {
12224                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12225                }
12226                Ok(RiseCtlPauseVersionCheckpointResponse {
12227                })
12228            }
12229        }
12230        deserializer.deserialize_struct("hummock.RiseCtlPauseVersionCheckpointResponse", FIELDS, GeneratedVisitor)
12231    }
12232}
12233impl serde::Serialize for RiseCtlRebuildTableStatsRequest {
12234    #[allow(deprecated)]
12235    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12236    where
12237        S: serde::Serializer,
12238    {
12239        use serde::ser::SerializeStruct;
12240        let len = 0;
12241        let struct_ser = serializer.serialize_struct("hummock.RiseCtlRebuildTableStatsRequest", len)?;
12242        struct_ser.end()
12243    }
12244}
12245impl<'de> serde::Deserialize<'de> for RiseCtlRebuildTableStatsRequest {
12246    #[allow(deprecated)]
12247    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12248    where
12249        D: serde::Deserializer<'de>,
12250    {
12251        const FIELDS: &[&str] = &[
12252        ];
12253
12254        #[allow(clippy::enum_variant_names)]
12255        enum GeneratedField {
12256        }
12257        impl<'de> serde::Deserialize<'de> for GeneratedField {
12258            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12259            where
12260                D: serde::Deserializer<'de>,
12261            {
12262                struct GeneratedVisitor;
12263
12264                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12265                    type Value = GeneratedField;
12266
12267                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12268                        write!(formatter, "expected one of: {:?}", &FIELDS)
12269                    }
12270
12271                    #[allow(unused_variables)]
12272                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12273                    where
12274                        E: serde::de::Error,
12275                    {
12276                            Err(serde::de::Error::unknown_field(value, FIELDS))
12277                    }
12278                }
12279                deserializer.deserialize_identifier(GeneratedVisitor)
12280            }
12281        }
12282        struct GeneratedVisitor;
12283        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12284            type Value = RiseCtlRebuildTableStatsRequest;
12285
12286            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12287                formatter.write_str("struct hummock.RiseCtlRebuildTableStatsRequest")
12288            }
12289
12290            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlRebuildTableStatsRequest, V::Error>
12291                where
12292                    V: serde::de::MapAccess<'de>,
12293            {
12294                while map_.next_key::<GeneratedField>()?.is_some() {
12295                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12296                }
12297                Ok(RiseCtlRebuildTableStatsRequest {
12298                })
12299            }
12300        }
12301        deserializer.deserialize_struct("hummock.RiseCtlRebuildTableStatsRequest", FIELDS, GeneratedVisitor)
12302    }
12303}
12304impl serde::Serialize for RiseCtlRebuildTableStatsResponse {
12305    #[allow(deprecated)]
12306    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12307    where
12308        S: serde::Serializer,
12309    {
12310        use serde::ser::SerializeStruct;
12311        let len = 0;
12312        let struct_ser = serializer.serialize_struct("hummock.RiseCtlRebuildTableStatsResponse", len)?;
12313        struct_ser.end()
12314    }
12315}
12316impl<'de> serde::Deserialize<'de> for RiseCtlRebuildTableStatsResponse {
12317    #[allow(deprecated)]
12318    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12319    where
12320        D: serde::Deserializer<'de>,
12321    {
12322        const FIELDS: &[&str] = &[
12323        ];
12324
12325        #[allow(clippy::enum_variant_names)]
12326        enum GeneratedField {
12327        }
12328        impl<'de> serde::Deserialize<'de> for GeneratedField {
12329            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12330            where
12331                D: serde::Deserializer<'de>,
12332            {
12333                struct GeneratedVisitor;
12334
12335                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12336                    type Value = GeneratedField;
12337
12338                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12339                        write!(formatter, "expected one of: {:?}", &FIELDS)
12340                    }
12341
12342                    #[allow(unused_variables)]
12343                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12344                    where
12345                        E: serde::de::Error,
12346                    {
12347                            Err(serde::de::Error::unknown_field(value, FIELDS))
12348                    }
12349                }
12350                deserializer.deserialize_identifier(GeneratedVisitor)
12351            }
12352        }
12353        struct GeneratedVisitor;
12354        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12355            type Value = RiseCtlRebuildTableStatsResponse;
12356
12357            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12358                formatter.write_str("struct hummock.RiseCtlRebuildTableStatsResponse")
12359            }
12360
12361            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlRebuildTableStatsResponse, V::Error>
12362                where
12363                    V: serde::de::MapAccess<'de>,
12364            {
12365                while map_.next_key::<GeneratedField>()?.is_some() {
12366                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12367                }
12368                Ok(RiseCtlRebuildTableStatsResponse {
12369                })
12370            }
12371        }
12372        deserializer.deserialize_struct("hummock.RiseCtlRebuildTableStatsResponse", FIELDS, GeneratedVisitor)
12373    }
12374}
12375impl serde::Serialize for RiseCtlResumeVersionCheckpointRequest {
12376    #[allow(deprecated)]
12377    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12378    where
12379        S: serde::Serializer,
12380    {
12381        use serde::ser::SerializeStruct;
12382        let len = 0;
12383        let struct_ser = serializer.serialize_struct("hummock.RiseCtlResumeVersionCheckpointRequest", len)?;
12384        struct_ser.end()
12385    }
12386}
12387impl<'de> serde::Deserialize<'de> for RiseCtlResumeVersionCheckpointRequest {
12388    #[allow(deprecated)]
12389    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12390    where
12391        D: serde::Deserializer<'de>,
12392    {
12393        const FIELDS: &[&str] = &[
12394        ];
12395
12396        #[allow(clippy::enum_variant_names)]
12397        enum GeneratedField {
12398        }
12399        impl<'de> serde::Deserialize<'de> for GeneratedField {
12400            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12401            where
12402                D: serde::Deserializer<'de>,
12403            {
12404                struct GeneratedVisitor;
12405
12406                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12407                    type Value = GeneratedField;
12408
12409                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12410                        write!(formatter, "expected one of: {:?}", &FIELDS)
12411                    }
12412
12413                    #[allow(unused_variables)]
12414                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12415                    where
12416                        E: serde::de::Error,
12417                    {
12418                            Err(serde::de::Error::unknown_field(value, FIELDS))
12419                    }
12420                }
12421                deserializer.deserialize_identifier(GeneratedVisitor)
12422            }
12423        }
12424        struct GeneratedVisitor;
12425        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12426            type Value = RiseCtlResumeVersionCheckpointRequest;
12427
12428            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12429                formatter.write_str("struct hummock.RiseCtlResumeVersionCheckpointRequest")
12430            }
12431
12432            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlResumeVersionCheckpointRequest, V::Error>
12433                where
12434                    V: serde::de::MapAccess<'de>,
12435            {
12436                while map_.next_key::<GeneratedField>()?.is_some() {
12437                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12438                }
12439                Ok(RiseCtlResumeVersionCheckpointRequest {
12440                })
12441            }
12442        }
12443        deserializer.deserialize_struct("hummock.RiseCtlResumeVersionCheckpointRequest", FIELDS, GeneratedVisitor)
12444    }
12445}
12446impl serde::Serialize for RiseCtlResumeVersionCheckpointResponse {
12447    #[allow(deprecated)]
12448    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12449    where
12450        S: serde::Serializer,
12451    {
12452        use serde::ser::SerializeStruct;
12453        let len = 0;
12454        let struct_ser = serializer.serialize_struct("hummock.RiseCtlResumeVersionCheckpointResponse", len)?;
12455        struct_ser.end()
12456    }
12457}
12458impl<'de> serde::Deserialize<'de> for RiseCtlResumeVersionCheckpointResponse {
12459    #[allow(deprecated)]
12460    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12461    where
12462        D: serde::Deserializer<'de>,
12463    {
12464        const FIELDS: &[&str] = &[
12465        ];
12466
12467        #[allow(clippy::enum_variant_names)]
12468        enum GeneratedField {
12469        }
12470        impl<'de> serde::Deserialize<'de> for GeneratedField {
12471            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12472            where
12473                D: serde::Deserializer<'de>,
12474            {
12475                struct GeneratedVisitor;
12476
12477                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12478                    type Value = GeneratedField;
12479
12480                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12481                        write!(formatter, "expected one of: {:?}", &FIELDS)
12482                    }
12483
12484                    #[allow(unused_variables)]
12485                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12486                    where
12487                        E: serde::de::Error,
12488                    {
12489                            Err(serde::de::Error::unknown_field(value, FIELDS))
12490                    }
12491                }
12492                deserializer.deserialize_identifier(GeneratedVisitor)
12493            }
12494        }
12495        struct GeneratedVisitor;
12496        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12497            type Value = RiseCtlResumeVersionCheckpointResponse;
12498
12499            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12500                formatter.write_str("struct hummock.RiseCtlResumeVersionCheckpointResponse")
12501            }
12502
12503            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlResumeVersionCheckpointResponse, V::Error>
12504                where
12505                    V: serde::de::MapAccess<'de>,
12506            {
12507                while map_.next_key::<GeneratedField>()?.is_some() {
12508                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12509                }
12510                Ok(RiseCtlResumeVersionCheckpointResponse {
12511                })
12512            }
12513        }
12514        deserializer.deserialize_struct("hummock.RiseCtlResumeVersionCheckpointResponse", FIELDS, GeneratedVisitor)
12515    }
12516}
12517impl serde::Serialize for RiseCtlUpdateCompactionConfigRequest {
12518    #[allow(deprecated)]
12519    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12520    where
12521        S: serde::Serializer,
12522    {
12523        use serde::ser::SerializeStruct;
12524        let mut len = 0;
12525        if !self.compaction_group_ids.is_empty() {
12526            len += 1;
12527        }
12528        if !self.configs.is_empty() {
12529            len += 1;
12530        }
12531        let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest", len)?;
12532        if !self.compaction_group_ids.is_empty() {
12533            struct_ser.serialize_field("compactionGroupIds", &self.compaction_group_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
12534        }
12535        if !self.configs.is_empty() {
12536            struct_ser.serialize_field("configs", &self.configs)?;
12537        }
12538        struct_ser.end()
12539    }
12540}
12541impl<'de> serde::Deserialize<'de> for RiseCtlUpdateCompactionConfigRequest {
12542    #[allow(deprecated)]
12543    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12544    where
12545        D: serde::Deserializer<'de>,
12546    {
12547        const FIELDS: &[&str] = &[
12548            "compaction_group_ids",
12549            "compactionGroupIds",
12550            "configs",
12551        ];
12552
12553        #[allow(clippy::enum_variant_names)]
12554        enum GeneratedField {
12555            CompactionGroupIds,
12556            Configs,
12557        }
12558        impl<'de> serde::Deserialize<'de> for GeneratedField {
12559            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12560            where
12561                D: serde::Deserializer<'de>,
12562            {
12563                struct GeneratedVisitor;
12564
12565                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12566                    type Value = GeneratedField;
12567
12568                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12569                        write!(formatter, "expected one of: {:?}", &FIELDS)
12570                    }
12571
12572                    #[allow(unused_variables)]
12573                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12574                    where
12575                        E: serde::de::Error,
12576                    {
12577                        match value {
12578                            "compactionGroupIds" | "compaction_group_ids" => Ok(GeneratedField::CompactionGroupIds),
12579                            "configs" => Ok(GeneratedField::Configs),
12580                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12581                        }
12582                    }
12583                }
12584                deserializer.deserialize_identifier(GeneratedVisitor)
12585            }
12586        }
12587        struct GeneratedVisitor;
12588        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12589            type Value = RiseCtlUpdateCompactionConfigRequest;
12590
12591            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12592                formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigRequest")
12593            }
12594
12595            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlUpdateCompactionConfigRequest, V::Error>
12596                where
12597                    V: serde::de::MapAccess<'de>,
12598            {
12599                let mut compaction_group_ids__ = None;
12600                let mut configs__ = None;
12601                while let Some(k) = map_.next_key()? {
12602                    match k {
12603                        GeneratedField::CompactionGroupIds => {
12604                            if compaction_group_ids__.is_some() {
12605                                return Err(serde::de::Error::duplicate_field("compactionGroupIds"));
12606                            }
12607                            compaction_group_ids__ = 
12608                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12609                                    .into_iter().map(|x| x.0).collect())
12610                            ;
12611                        }
12612                        GeneratedField::Configs => {
12613                            if configs__.is_some() {
12614                                return Err(serde::de::Error::duplicate_field("configs"));
12615                            }
12616                            configs__ = Some(map_.next_value()?);
12617                        }
12618                    }
12619                }
12620                Ok(RiseCtlUpdateCompactionConfigRequest {
12621                    compaction_group_ids: compaction_group_ids__.unwrap_or_default(),
12622                    configs: configs__.unwrap_or_default(),
12623                })
12624            }
12625        }
12626        deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest", FIELDS, GeneratedVisitor)
12627    }
12628}
12629impl serde::Serialize for rise_ctl_update_compaction_config_request::CompressionAlgorithm {
12630    #[allow(deprecated)]
12631    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12632    where
12633        S: serde::Serializer,
12634    {
12635        use serde::ser::SerializeStruct;
12636        let mut len = 0;
12637        if self.level != 0 {
12638            len += 1;
12639        }
12640        if !self.compression_algorithm.is_empty() {
12641            len += 1;
12642        }
12643        let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.CompressionAlgorithm", len)?;
12644        if self.level != 0 {
12645            struct_ser.serialize_field("level", &self.level)?;
12646        }
12647        if !self.compression_algorithm.is_empty() {
12648            struct_ser.serialize_field("compressionAlgorithm", &self.compression_algorithm)?;
12649        }
12650        struct_ser.end()
12651    }
12652}
12653impl<'de> serde::Deserialize<'de> for rise_ctl_update_compaction_config_request::CompressionAlgorithm {
12654    #[allow(deprecated)]
12655    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12656    where
12657        D: serde::Deserializer<'de>,
12658    {
12659        const FIELDS: &[&str] = &[
12660            "level",
12661            "compression_algorithm",
12662            "compressionAlgorithm",
12663        ];
12664
12665        #[allow(clippy::enum_variant_names)]
12666        enum GeneratedField {
12667            Level,
12668            CompressionAlgorithm,
12669        }
12670        impl<'de> serde::Deserialize<'de> for GeneratedField {
12671            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12672            where
12673                D: serde::Deserializer<'de>,
12674            {
12675                struct GeneratedVisitor;
12676
12677                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12678                    type Value = GeneratedField;
12679
12680                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12681                        write!(formatter, "expected one of: {:?}", &FIELDS)
12682                    }
12683
12684                    #[allow(unused_variables)]
12685                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12686                    where
12687                        E: serde::de::Error,
12688                    {
12689                        match value {
12690                            "level" => Ok(GeneratedField::Level),
12691                            "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
12692                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12693                        }
12694                    }
12695                }
12696                deserializer.deserialize_identifier(GeneratedVisitor)
12697            }
12698        }
12699        struct GeneratedVisitor;
12700        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12701            type Value = rise_ctl_update_compaction_config_request::CompressionAlgorithm;
12702
12703            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12704                formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigRequest.CompressionAlgorithm")
12705            }
12706
12707            fn visit_map<V>(self, mut map_: V) -> std::result::Result<rise_ctl_update_compaction_config_request::CompressionAlgorithm, V::Error>
12708                where
12709                    V: serde::de::MapAccess<'de>,
12710            {
12711                let mut level__ = None;
12712                let mut compression_algorithm__ = None;
12713                while let Some(k) = map_.next_key()? {
12714                    match k {
12715                        GeneratedField::Level => {
12716                            if level__.is_some() {
12717                                return Err(serde::de::Error::duplicate_field("level"));
12718                            }
12719                            level__ = 
12720                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12721                            ;
12722                        }
12723                        GeneratedField::CompressionAlgorithm => {
12724                            if compression_algorithm__.is_some() {
12725                                return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
12726                            }
12727                            compression_algorithm__ = Some(map_.next_value()?);
12728                        }
12729                    }
12730                }
12731                Ok(rise_ctl_update_compaction_config_request::CompressionAlgorithm {
12732                    level: level__.unwrap_or_default(),
12733                    compression_algorithm: compression_algorithm__.unwrap_or_default(),
12734                })
12735            }
12736        }
12737        deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.CompressionAlgorithm", FIELDS, GeneratedVisitor)
12738    }
12739}
12740impl serde::Serialize for rise_ctl_update_compaction_config_request::MutableConfig {
12741    #[allow(deprecated)]
12742    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12743    where
12744        S: serde::Serializer,
12745    {
12746        use serde::ser::SerializeStruct;
12747        let mut len = 0;
12748        if self.mutable_config.is_some() {
12749            len += 1;
12750        }
12751        let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.MutableConfig", len)?;
12752        if let Some(v) = self.mutable_config.as_ref() {
12753            match v {
12754                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxBytesForLevelBase(v) => {
12755                    #[allow(clippy::needless_borrow)]
12756                    #[allow(clippy::needless_borrows_for_generic_args)]
12757                    struct_ser.serialize_field("maxBytesForLevelBase", ToString::to_string(&v).as_str())?;
12758                }
12759                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxBytesForLevelMultiplier(v) => {
12760                    #[allow(clippy::needless_borrow)]
12761                    #[allow(clippy::needless_borrows_for_generic_args)]
12762                    struct_ser.serialize_field("maxBytesForLevelMultiplier", ToString::to_string(&v).as_str())?;
12763                }
12764                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxCompactionBytes(v) => {
12765                    #[allow(clippy::needless_borrow)]
12766                    #[allow(clippy::needless_borrows_for_generic_args)]
12767                    struct_ser.serialize_field("maxCompactionBytes", ToString::to_string(&v).as_str())?;
12768                }
12769                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SubLevelMaxCompactionBytes(v) => {
12770                    #[allow(clippy::needless_borrow)]
12771                    #[allow(clippy::needless_borrows_for_generic_args)]
12772                    struct_ser.serialize_field("subLevelMaxCompactionBytes", ToString::to_string(&v).as_str())?;
12773                }
12774                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0TierCompactFileNumber(v) => {
12775                    #[allow(clippy::needless_borrow)]
12776                    #[allow(clippy::needless_borrows_for_generic_args)]
12777                    struct_ser.serialize_field("level0TierCompactFileNumber", ToString::to_string(&v).as_str())?;
12778                }
12779                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::TargetFileSizeBase(v) => {
12780                    #[allow(clippy::needless_borrow)]
12781                    #[allow(clippy::needless_borrows_for_generic_args)]
12782                    struct_ser.serialize_field("targetFileSizeBase", ToString::to_string(&v).as_str())?;
12783                }
12784                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::CompactionFilterMask(v) => {
12785                    struct_ser.serialize_field("compactionFilterMask", v)?;
12786                }
12787                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxSubCompaction(v) => {
12788                    struct_ser.serialize_field("maxSubCompaction", v)?;
12789                }
12790                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdSubLevelNumber(v) => {
12791                    #[allow(clippy::needless_borrow)]
12792                    #[allow(clippy::needless_borrows_for_generic_args)]
12793                    struct_ser.serialize_field("level0StopWriteThresholdSubLevelNumber", ToString::to_string(&v).as_str())?;
12794                }
12795                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0SubLevelCompactLevelCount(v) => {
12796                    struct_ser.serialize_field("level0SubLevelCompactLevelCount", v)?;
12797                }
12798                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0OverlappingSubLevelCompactLevelCount(v) => {
12799                    struct_ser.serialize_field("level0OverlappingSubLevelCompactLevelCount", v)?;
12800                }
12801                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxSpaceReclaimBytes(v) => {
12802                    #[allow(clippy::needless_borrow)]
12803                    #[allow(clippy::needless_borrows_for_generic_args)]
12804                    struct_ser.serialize_field("maxSpaceReclaimBytes", ToString::to_string(&v).as_str())?;
12805                }
12806                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0MaxCompactFileNumber(v) => {
12807                    #[allow(clippy::needless_borrow)]
12808                    #[allow(clippy::needless_borrows_for_generic_args)]
12809                    struct_ser.serialize_field("level0MaxCompactFileNumber", ToString::to_string(&v).as_str())?;
12810                }
12811                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableEmergencyPicker(v) => {
12812                    struct_ser.serialize_field("enableEmergencyPicker", v)?;
12813                }
12814                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::TombstoneReclaimRatio(v) => {
12815                    struct_ser.serialize_field("tombstoneReclaimRatio", v)?;
12816                }
12817                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::CompressionAlgorithm(v) => {
12818                    struct_ser.serialize_field("compressionAlgorithm", v)?;
12819                }
12820                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxL0CompactLevelCount(v) => {
12821                    struct_ser.serialize_field("maxL0CompactLevelCount", v)?;
12822                }
12823                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SstAllowedTrivialMoveMinSize(v) => {
12824                    #[allow(clippy::needless_borrow)]
12825                    #[allow(clippy::needless_borrows_for_generic_args)]
12826                    struct_ser.serialize_field("sstAllowedTrivialMoveMinSize", ToString::to_string(&v).as_str())?;
12827                }
12828                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SplitWeightByVnode(v) => {
12829                    struct_ser.serialize_field("splitWeightByVnode", v)?;
12830                }
12831                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::DisableAutoGroupScheduling(v) => {
12832                    struct_ser.serialize_field("disableAutoGroupScheduling", v)?;
12833                }
12834                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxOverlappingLevelSize(v) => {
12835                    #[allow(clippy::needless_borrow)]
12836                    #[allow(clippy::needless_borrows_for_generic_args)]
12837                    struct_ser.serialize_field("maxOverlappingLevelSize", ToString::to_string(&v).as_str())?;
12838                }
12839                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EmergencyLevel0SstFileCount(v) => {
12840                    struct_ser.serialize_field("emergencyLevel0SstFileCount", v)?;
12841                }
12842                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EmergencyLevel0SubLevelPartition(v) => {
12843                    struct_ser.serialize_field("emergencyLevel0SubLevelPartition", v)?;
12844                }
12845                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdMaxSstCount(v) => {
12846                    struct_ser.serialize_field("level0StopWriteThresholdMaxSstCount", v)?;
12847                }
12848                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdMaxSize(v) => {
12849                    #[allow(clippy::needless_borrow)]
12850                    #[allow(clippy::needless_borrows_for_generic_args)]
12851                    struct_ser.serialize_field("level0StopWriteThresholdMaxSize", ToString::to_string(&v).as_str())?;
12852                }
12853                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SstAllowedTrivialMoveMaxCount(v) => {
12854                    struct_ser.serialize_field("sstAllowedTrivialMoveMaxCount", v)?;
12855                }
12856                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableOptimizeL0IntervalSelection(v) => {
12857                    struct_ser.serialize_field("enableOptimizeL0IntervalSelection", v)?;
12858                }
12859            }
12860        }
12861        struct_ser.end()
12862    }
12863}
12864impl<'de> serde::Deserialize<'de> for rise_ctl_update_compaction_config_request::MutableConfig {
12865    #[allow(deprecated)]
12866    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12867    where
12868        D: serde::Deserializer<'de>,
12869    {
12870        const FIELDS: &[&str] = &[
12871            "max_bytes_for_level_base",
12872            "maxBytesForLevelBase",
12873            "max_bytes_for_level_multiplier",
12874            "maxBytesForLevelMultiplier",
12875            "max_compaction_bytes",
12876            "maxCompactionBytes",
12877            "sub_level_max_compaction_bytes",
12878            "subLevelMaxCompactionBytes",
12879            "level0_tier_compact_file_number",
12880            "level0TierCompactFileNumber",
12881            "target_file_size_base",
12882            "targetFileSizeBase",
12883            "compaction_filter_mask",
12884            "compactionFilterMask",
12885            "max_sub_compaction",
12886            "maxSubCompaction",
12887            "level0_stop_write_threshold_sub_level_number",
12888            "level0StopWriteThresholdSubLevelNumber",
12889            "level0_sub_level_compact_level_count",
12890            "level0SubLevelCompactLevelCount",
12891            "level0_overlapping_sub_level_compact_level_count",
12892            "level0OverlappingSubLevelCompactLevelCount",
12893            "max_space_reclaim_bytes",
12894            "maxSpaceReclaimBytes",
12895            "level0_max_compact_file_number",
12896            "level0MaxCompactFileNumber",
12897            "enable_emergency_picker",
12898            "enableEmergencyPicker",
12899            "tombstone_reclaim_ratio",
12900            "tombstoneReclaimRatio",
12901            "compression_algorithm",
12902            "compressionAlgorithm",
12903            "max_l0_compact_level_count",
12904            "maxL0CompactLevelCount",
12905            "sst_allowed_trivial_move_min_size",
12906            "sstAllowedTrivialMoveMinSize",
12907            "split_weight_by_vnode",
12908            "splitWeightByVnode",
12909            "disable_auto_group_scheduling",
12910            "disableAutoGroupScheduling",
12911            "max_overlapping_level_size",
12912            "maxOverlappingLevelSize",
12913            "emergency_level0_sst_file_count",
12914            "emergencyLevel0SstFileCount",
12915            "emergency_level0_sub_level_partition",
12916            "emergencyLevel0SubLevelPartition",
12917            "level0_stop_write_threshold_max_sst_count",
12918            "level0StopWriteThresholdMaxSstCount",
12919            "level0_stop_write_threshold_max_size",
12920            "level0StopWriteThresholdMaxSize",
12921            "sst_allowed_trivial_move_max_count",
12922            "sstAllowedTrivialMoveMaxCount",
12923            "enable_optimize_l0_interval_selection",
12924            "enableOptimizeL0IntervalSelection",
12925        ];
12926
12927        #[allow(clippy::enum_variant_names)]
12928        enum GeneratedField {
12929            MaxBytesForLevelBase,
12930            MaxBytesForLevelMultiplier,
12931            MaxCompactionBytes,
12932            SubLevelMaxCompactionBytes,
12933            Level0TierCompactFileNumber,
12934            TargetFileSizeBase,
12935            CompactionFilterMask,
12936            MaxSubCompaction,
12937            Level0StopWriteThresholdSubLevelNumber,
12938            Level0SubLevelCompactLevelCount,
12939            Level0OverlappingSubLevelCompactLevelCount,
12940            MaxSpaceReclaimBytes,
12941            Level0MaxCompactFileNumber,
12942            EnableEmergencyPicker,
12943            TombstoneReclaimRatio,
12944            CompressionAlgorithm,
12945            MaxL0CompactLevelCount,
12946            SstAllowedTrivialMoveMinSize,
12947            SplitWeightByVnode,
12948            DisableAutoGroupScheduling,
12949            MaxOverlappingLevelSize,
12950            EmergencyLevel0SstFileCount,
12951            EmergencyLevel0SubLevelPartition,
12952            Level0StopWriteThresholdMaxSstCount,
12953            Level0StopWriteThresholdMaxSize,
12954            SstAllowedTrivialMoveMaxCount,
12955            EnableOptimizeL0IntervalSelection,
12956        }
12957        impl<'de> serde::Deserialize<'de> for GeneratedField {
12958            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12959            where
12960                D: serde::Deserializer<'de>,
12961            {
12962                struct GeneratedVisitor;
12963
12964                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12965                    type Value = GeneratedField;
12966
12967                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12968                        write!(formatter, "expected one of: {:?}", &FIELDS)
12969                    }
12970
12971                    #[allow(unused_variables)]
12972                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12973                    where
12974                        E: serde::de::Error,
12975                    {
12976                        match value {
12977                            "maxBytesForLevelBase" | "max_bytes_for_level_base" => Ok(GeneratedField::MaxBytesForLevelBase),
12978                            "maxBytesForLevelMultiplier" | "max_bytes_for_level_multiplier" => Ok(GeneratedField::MaxBytesForLevelMultiplier),
12979                            "maxCompactionBytes" | "max_compaction_bytes" => Ok(GeneratedField::MaxCompactionBytes),
12980                            "subLevelMaxCompactionBytes" | "sub_level_max_compaction_bytes" => Ok(GeneratedField::SubLevelMaxCompactionBytes),
12981                            "level0TierCompactFileNumber" | "level0_tier_compact_file_number" => Ok(GeneratedField::Level0TierCompactFileNumber),
12982                            "targetFileSizeBase" | "target_file_size_base" => Ok(GeneratedField::TargetFileSizeBase),
12983                            "compactionFilterMask" | "compaction_filter_mask" => Ok(GeneratedField::CompactionFilterMask),
12984                            "maxSubCompaction" | "max_sub_compaction" => Ok(GeneratedField::MaxSubCompaction),
12985                            "level0StopWriteThresholdSubLevelNumber" | "level0_stop_write_threshold_sub_level_number" => Ok(GeneratedField::Level0StopWriteThresholdSubLevelNumber),
12986                            "level0SubLevelCompactLevelCount" | "level0_sub_level_compact_level_count" => Ok(GeneratedField::Level0SubLevelCompactLevelCount),
12987                            "level0OverlappingSubLevelCompactLevelCount" | "level0_overlapping_sub_level_compact_level_count" => Ok(GeneratedField::Level0OverlappingSubLevelCompactLevelCount),
12988                            "maxSpaceReclaimBytes" | "max_space_reclaim_bytes" => Ok(GeneratedField::MaxSpaceReclaimBytes),
12989                            "level0MaxCompactFileNumber" | "level0_max_compact_file_number" => Ok(GeneratedField::Level0MaxCompactFileNumber),
12990                            "enableEmergencyPicker" | "enable_emergency_picker" => Ok(GeneratedField::EnableEmergencyPicker),
12991                            "tombstoneReclaimRatio" | "tombstone_reclaim_ratio" => Ok(GeneratedField::TombstoneReclaimRatio),
12992                            "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
12993                            "maxL0CompactLevelCount" | "max_l0_compact_level_count" => Ok(GeneratedField::MaxL0CompactLevelCount),
12994                            "sstAllowedTrivialMoveMinSize" | "sst_allowed_trivial_move_min_size" => Ok(GeneratedField::SstAllowedTrivialMoveMinSize),
12995                            "splitWeightByVnode" | "split_weight_by_vnode" => Ok(GeneratedField::SplitWeightByVnode),
12996                            "disableAutoGroupScheduling" | "disable_auto_group_scheduling" => Ok(GeneratedField::DisableAutoGroupScheduling),
12997                            "maxOverlappingLevelSize" | "max_overlapping_level_size" => Ok(GeneratedField::MaxOverlappingLevelSize),
12998                            "emergencyLevel0SstFileCount" | "emergency_level0_sst_file_count" => Ok(GeneratedField::EmergencyLevel0SstFileCount),
12999                            "emergencyLevel0SubLevelPartition" | "emergency_level0_sub_level_partition" => Ok(GeneratedField::EmergencyLevel0SubLevelPartition),
13000                            "level0StopWriteThresholdMaxSstCount" | "level0_stop_write_threshold_max_sst_count" => Ok(GeneratedField::Level0StopWriteThresholdMaxSstCount),
13001                            "level0StopWriteThresholdMaxSize" | "level0_stop_write_threshold_max_size" => Ok(GeneratedField::Level0StopWriteThresholdMaxSize),
13002                            "sstAllowedTrivialMoveMaxCount" | "sst_allowed_trivial_move_max_count" => Ok(GeneratedField::SstAllowedTrivialMoveMaxCount),
13003                            "enableOptimizeL0IntervalSelection" | "enable_optimize_l0_interval_selection" => Ok(GeneratedField::EnableOptimizeL0IntervalSelection),
13004                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13005                        }
13006                    }
13007                }
13008                deserializer.deserialize_identifier(GeneratedVisitor)
13009            }
13010        }
13011        struct GeneratedVisitor;
13012        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13013            type Value = rise_ctl_update_compaction_config_request::MutableConfig;
13014
13015            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13016                formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigRequest.MutableConfig")
13017            }
13018
13019            fn visit_map<V>(self, mut map_: V) -> std::result::Result<rise_ctl_update_compaction_config_request::MutableConfig, V::Error>
13020                where
13021                    V: serde::de::MapAccess<'de>,
13022            {
13023                let mut mutable_config__ = None;
13024                while let Some(k) = map_.next_key()? {
13025                    match k {
13026                        GeneratedField::MaxBytesForLevelBase => {
13027                            if mutable_config__.is_some() {
13028                                return Err(serde::de::Error::duplicate_field("maxBytesForLevelBase"));
13029                            }
13030                            mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxBytesForLevelBase(x.0));
13031                        }
13032                        GeneratedField::MaxBytesForLevelMultiplier => {
13033                            if mutable_config__.is_some() {
13034                                return Err(serde::de::Error::duplicate_field("maxBytesForLevelMultiplier"));
13035                            }
13036                            mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxBytesForLevelMultiplier(x.0));
13037                        }
13038                        GeneratedField::MaxCompactionBytes => {
13039                            if mutable_config__.is_some() {
13040                                return Err(serde::de::Error::duplicate_field("maxCompactionBytes"));
13041                            }
13042                            mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxCompactionBytes(x.0));
13043                        }
13044                        GeneratedField::SubLevelMaxCompactionBytes => {
13045                            if mutable_config__.is_some() {
13046                                return Err(serde::de::Error::duplicate_field("subLevelMaxCompactionBytes"));
13047                            }
13048                            mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SubLevelMaxCompactionBytes(x.0));
13049                        }
13050                        GeneratedField::Level0TierCompactFileNumber => {
13051                            if mutable_config__.is_some() {
13052                                return Err(serde::de::Error::duplicate_field("level0TierCompactFileNumber"));
13053                            }
13054                            mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0TierCompactFileNumber(x.0));
13055                        }
13056                        GeneratedField::TargetFileSizeBase => {
13057                            if mutable_config__.is_some() {
13058                                return Err(serde::de::Error::duplicate_field("targetFileSizeBase"));
13059                            }
13060                            mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::TargetFileSizeBase(x.0));
13061                        }
13062                        GeneratedField::CompactionFilterMask => {
13063                            if mutable_config__.is_some() {
13064                                return Err(serde::de::Error::duplicate_field("compactionFilterMask"));
13065                            }
13066                            mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::CompactionFilterMask(x.0));
13067                        }
13068                        GeneratedField::MaxSubCompaction => {
13069                            if mutable_config__.is_some() {
13070                                return Err(serde::de::Error::duplicate_field("maxSubCompaction"));
13071                            }
13072                            mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxSubCompaction(x.0));
13073                        }
13074                        GeneratedField::Level0StopWriteThresholdSubLevelNumber => {
13075                            if mutable_config__.is_some() {
13076                                return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdSubLevelNumber"));
13077                            }
13078                            mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdSubLevelNumber(x.0));
13079                        }
13080                        GeneratedField::Level0SubLevelCompactLevelCount => {
13081                            if mutable_config__.is_some() {
13082                                return Err(serde::de::Error::duplicate_field("level0SubLevelCompactLevelCount"));
13083                            }
13084                            mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0SubLevelCompactLevelCount(x.0));
13085                        }
13086                        GeneratedField::Level0OverlappingSubLevelCompactLevelCount => {
13087                            if mutable_config__.is_some() {
13088                                return Err(serde::de::Error::duplicate_field("level0OverlappingSubLevelCompactLevelCount"));
13089                            }
13090                            mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0OverlappingSubLevelCompactLevelCount(x.0));
13091                        }
13092                        GeneratedField::MaxSpaceReclaimBytes => {
13093                            if mutable_config__.is_some() {
13094                                return Err(serde::de::Error::duplicate_field("maxSpaceReclaimBytes"));
13095                            }
13096                            mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxSpaceReclaimBytes(x.0));
13097                        }
13098                        GeneratedField::Level0MaxCompactFileNumber => {
13099                            if mutable_config__.is_some() {
13100                                return Err(serde::de::Error::duplicate_field("level0MaxCompactFileNumber"));
13101                            }
13102                            mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0MaxCompactFileNumber(x.0));
13103                        }
13104                        GeneratedField::EnableEmergencyPicker => {
13105                            if mutable_config__.is_some() {
13106                                return Err(serde::de::Error::duplicate_field("enableEmergencyPicker"));
13107                            }
13108                            mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableEmergencyPicker);
13109                        }
13110                        GeneratedField::TombstoneReclaimRatio => {
13111                            if mutable_config__.is_some() {
13112                                return Err(serde::de::Error::duplicate_field("tombstoneReclaimRatio"));
13113                            }
13114                            mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::TombstoneReclaimRatio(x.0));
13115                        }
13116                        GeneratedField::CompressionAlgorithm => {
13117                            if mutable_config__.is_some() {
13118                                return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
13119                            }
13120                            mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::CompressionAlgorithm)
13121;
13122                        }
13123                        GeneratedField::MaxL0CompactLevelCount => {
13124                            if mutable_config__.is_some() {
13125                                return Err(serde::de::Error::duplicate_field("maxL0CompactLevelCount"));
13126                            }
13127                            mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxL0CompactLevelCount(x.0));
13128                        }
13129                        GeneratedField::SstAllowedTrivialMoveMinSize => {
13130                            if mutable_config__.is_some() {
13131                                return Err(serde::de::Error::duplicate_field("sstAllowedTrivialMoveMinSize"));
13132                            }
13133                            mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SstAllowedTrivialMoveMinSize(x.0));
13134                        }
13135                        GeneratedField::SplitWeightByVnode => {
13136                            if mutable_config__.is_some() {
13137                                return Err(serde::de::Error::duplicate_field("splitWeightByVnode"));
13138                            }
13139                            mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SplitWeightByVnode(x.0));
13140                        }
13141                        GeneratedField::DisableAutoGroupScheduling => {
13142                            if mutable_config__.is_some() {
13143                                return Err(serde::de::Error::duplicate_field("disableAutoGroupScheduling"));
13144                            }
13145                            mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::DisableAutoGroupScheduling);
13146                        }
13147                        GeneratedField::MaxOverlappingLevelSize => {
13148                            if mutable_config__.is_some() {
13149                                return Err(serde::de::Error::duplicate_field("maxOverlappingLevelSize"));
13150                            }
13151                            mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxOverlappingLevelSize(x.0));
13152                        }
13153                        GeneratedField::EmergencyLevel0SstFileCount => {
13154                            if mutable_config__.is_some() {
13155                                return Err(serde::de::Error::duplicate_field("emergencyLevel0SstFileCount"));
13156                            }
13157                            mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EmergencyLevel0SstFileCount(x.0));
13158                        }
13159                        GeneratedField::EmergencyLevel0SubLevelPartition => {
13160                            if mutable_config__.is_some() {
13161                                return Err(serde::de::Error::duplicate_field("emergencyLevel0SubLevelPartition"));
13162                            }
13163                            mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EmergencyLevel0SubLevelPartition(x.0));
13164                        }
13165                        GeneratedField::Level0StopWriteThresholdMaxSstCount => {
13166                            if mutable_config__.is_some() {
13167                                return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdMaxSstCount"));
13168                            }
13169                            mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdMaxSstCount(x.0));
13170                        }
13171                        GeneratedField::Level0StopWriteThresholdMaxSize => {
13172                            if mutable_config__.is_some() {
13173                                return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdMaxSize"));
13174                            }
13175                            mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdMaxSize(x.0));
13176                        }
13177                        GeneratedField::SstAllowedTrivialMoveMaxCount => {
13178                            if mutable_config__.is_some() {
13179                                return Err(serde::de::Error::duplicate_field("sstAllowedTrivialMoveMaxCount"));
13180                            }
13181                            mutable_config__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SstAllowedTrivialMoveMaxCount(x.0));
13182                        }
13183                        GeneratedField::EnableOptimizeL0IntervalSelection => {
13184                            if mutable_config__.is_some() {
13185                                return Err(serde::de::Error::duplicate_field("enableOptimizeL0IntervalSelection"));
13186                            }
13187                            mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableOptimizeL0IntervalSelection);
13188                        }
13189                    }
13190                }
13191                Ok(rise_ctl_update_compaction_config_request::MutableConfig {
13192                    mutable_config: mutable_config__,
13193                })
13194            }
13195        }
13196        deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.MutableConfig", FIELDS, GeneratedVisitor)
13197    }
13198}
13199impl serde::Serialize for RiseCtlUpdateCompactionConfigResponse {
13200    #[allow(deprecated)]
13201    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13202    where
13203        S: serde::Serializer,
13204    {
13205        use serde::ser::SerializeStruct;
13206        let mut len = 0;
13207        if self.status.is_some() {
13208            len += 1;
13209        }
13210        let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigResponse", len)?;
13211        if let Some(v) = self.status.as_ref() {
13212            struct_ser.serialize_field("status", v)?;
13213        }
13214        struct_ser.end()
13215    }
13216}
13217impl<'de> serde::Deserialize<'de> for RiseCtlUpdateCompactionConfigResponse {
13218    #[allow(deprecated)]
13219    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13220    where
13221        D: serde::Deserializer<'de>,
13222    {
13223        const FIELDS: &[&str] = &[
13224            "status",
13225        ];
13226
13227        #[allow(clippy::enum_variant_names)]
13228        enum GeneratedField {
13229            Status,
13230        }
13231        impl<'de> serde::Deserialize<'de> for GeneratedField {
13232            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13233            where
13234                D: serde::Deserializer<'de>,
13235            {
13236                struct GeneratedVisitor;
13237
13238                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13239                    type Value = GeneratedField;
13240
13241                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13242                        write!(formatter, "expected one of: {:?}", &FIELDS)
13243                    }
13244
13245                    #[allow(unused_variables)]
13246                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13247                    where
13248                        E: serde::de::Error,
13249                    {
13250                        match value {
13251                            "status" => Ok(GeneratedField::Status),
13252                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13253                        }
13254                    }
13255                }
13256                deserializer.deserialize_identifier(GeneratedVisitor)
13257            }
13258        }
13259        struct GeneratedVisitor;
13260        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13261            type Value = RiseCtlUpdateCompactionConfigResponse;
13262
13263            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13264                formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigResponse")
13265            }
13266
13267            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlUpdateCompactionConfigResponse, V::Error>
13268                where
13269                    V: serde::de::MapAccess<'de>,
13270            {
13271                let mut status__ = None;
13272                while let Some(k) = map_.next_key()? {
13273                    match k {
13274                        GeneratedField::Status => {
13275                            if status__.is_some() {
13276                                return Err(serde::de::Error::duplicate_field("status"));
13277                            }
13278                            status__ = map_.next_value()?;
13279                        }
13280                    }
13281                }
13282                Ok(RiseCtlUpdateCompactionConfigResponse {
13283                    status: status__,
13284                })
13285            }
13286        }
13287        deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigResponse", FIELDS, GeneratedVisitor)
13288    }
13289}
13290impl serde::Serialize for SplitCompactionGroupRequest {
13291    #[allow(deprecated)]
13292    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13293    where
13294        S: serde::Serializer,
13295    {
13296        use serde::ser::SerializeStruct;
13297        let mut len = 0;
13298        if self.group_id != 0 {
13299            len += 1;
13300        }
13301        if !self.table_ids.is_empty() {
13302            len += 1;
13303        }
13304        if self.partition_vnode_count != 0 {
13305            len += 1;
13306        }
13307        let mut struct_ser = serializer.serialize_struct("hummock.SplitCompactionGroupRequest", len)?;
13308        if self.group_id != 0 {
13309            #[allow(clippy::needless_borrow)]
13310            #[allow(clippy::needless_borrows_for_generic_args)]
13311            struct_ser.serialize_field("groupId", ToString::to_string(&self.group_id).as_str())?;
13312        }
13313        if !self.table_ids.is_empty() {
13314            struct_ser.serialize_field("tableIds", &self.table_ids)?;
13315        }
13316        if self.partition_vnode_count != 0 {
13317            struct_ser.serialize_field("partitionVnodeCount", &self.partition_vnode_count)?;
13318        }
13319        struct_ser.end()
13320    }
13321}
13322impl<'de> serde::Deserialize<'de> for SplitCompactionGroupRequest {
13323    #[allow(deprecated)]
13324    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13325    where
13326        D: serde::Deserializer<'de>,
13327    {
13328        const FIELDS: &[&str] = &[
13329            "group_id",
13330            "groupId",
13331            "table_ids",
13332            "tableIds",
13333            "partition_vnode_count",
13334            "partitionVnodeCount",
13335        ];
13336
13337        #[allow(clippy::enum_variant_names)]
13338        enum GeneratedField {
13339            GroupId,
13340            TableIds,
13341            PartitionVnodeCount,
13342        }
13343        impl<'de> serde::Deserialize<'de> for GeneratedField {
13344            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13345            where
13346                D: serde::Deserializer<'de>,
13347            {
13348                struct GeneratedVisitor;
13349
13350                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13351                    type Value = GeneratedField;
13352
13353                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13354                        write!(formatter, "expected one of: {:?}", &FIELDS)
13355                    }
13356
13357                    #[allow(unused_variables)]
13358                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13359                    where
13360                        E: serde::de::Error,
13361                    {
13362                        match value {
13363                            "groupId" | "group_id" => Ok(GeneratedField::GroupId),
13364                            "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
13365                            "partitionVnodeCount" | "partition_vnode_count" => Ok(GeneratedField::PartitionVnodeCount),
13366                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13367                        }
13368                    }
13369                }
13370                deserializer.deserialize_identifier(GeneratedVisitor)
13371            }
13372        }
13373        struct GeneratedVisitor;
13374        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13375            type Value = SplitCompactionGroupRequest;
13376
13377            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13378                formatter.write_str("struct hummock.SplitCompactionGroupRequest")
13379            }
13380
13381            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SplitCompactionGroupRequest, V::Error>
13382                where
13383                    V: serde::de::MapAccess<'de>,
13384            {
13385                let mut group_id__ = None;
13386                let mut table_ids__ = None;
13387                let mut partition_vnode_count__ = None;
13388                while let Some(k) = map_.next_key()? {
13389                    match k {
13390                        GeneratedField::GroupId => {
13391                            if group_id__.is_some() {
13392                                return Err(serde::de::Error::duplicate_field("groupId"));
13393                            }
13394                            group_id__ = 
13395                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13396                            ;
13397                        }
13398                        GeneratedField::TableIds => {
13399                            if table_ids__.is_some() {
13400                                return Err(serde::de::Error::duplicate_field("tableIds"));
13401                            }
13402                            table_ids__ = 
13403                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13404                                    .into_iter().map(|x| x.0).collect())
13405                            ;
13406                        }
13407                        GeneratedField::PartitionVnodeCount => {
13408                            if partition_vnode_count__.is_some() {
13409                                return Err(serde::de::Error::duplicate_field("partitionVnodeCount"));
13410                            }
13411                            partition_vnode_count__ = 
13412                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13413                            ;
13414                        }
13415                    }
13416                }
13417                Ok(SplitCompactionGroupRequest {
13418                    group_id: group_id__.unwrap_or_default(),
13419                    table_ids: table_ids__.unwrap_or_default(),
13420                    partition_vnode_count: partition_vnode_count__.unwrap_or_default(),
13421                })
13422            }
13423        }
13424        deserializer.deserialize_struct("hummock.SplitCompactionGroupRequest", FIELDS, GeneratedVisitor)
13425    }
13426}
13427impl serde::Serialize for SplitCompactionGroupResponse {
13428    #[allow(deprecated)]
13429    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13430    where
13431        S: serde::Serializer,
13432    {
13433        use serde::ser::SerializeStruct;
13434        let mut len = 0;
13435        if self.new_group_id != 0 {
13436            len += 1;
13437        }
13438        let mut struct_ser = serializer.serialize_struct("hummock.SplitCompactionGroupResponse", len)?;
13439        if self.new_group_id != 0 {
13440            #[allow(clippy::needless_borrow)]
13441            #[allow(clippy::needless_borrows_for_generic_args)]
13442            struct_ser.serialize_field("newGroupId", ToString::to_string(&self.new_group_id).as_str())?;
13443        }
13444        struct_ser.end()
13445    }
13446}
13447impl<'de> serde::Deserialize<'de> for SplitCompactionGroupResponse {
13448    #[allow(deprecated)]
13449    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13450    where
13451        D: serde::Deserializer<'de>,
13452    {
13453        const FIELDS: &[&str] = &[
13454            "new_group_id",
13455            "newGroupId",
13456        ];
13457
13458        #[allow(clippy::enum_variant_names)]
13459        enum GeneratedField {
13460            NewGroupId,
13461        }
13462        impl<'de> serde::Deserialize<'de> for GeneratedField {
13463            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13464            where
13465                D: serde::Deserializer<'de>,
13466            {
13467                struct GeneratedVisitor;
13468
13469                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13470                    type Value = GeneratedField;
13471
13472                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13473                        write!(formatter, "expected one of: {:?}", &FIELDS)
13474                    }
13475
13476                    #[allow(unused_variables)]
13477                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13478                    where
13479                        E: serde::de::Error,
13480                    {
13481                        match value {
13482                            "newGroupId" | "new_group_id" => Ok(GeneratedField::NewGroupId),
13483                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13484                        }
13485                    }
13486                }
13487                deserializer.deserialize_identifier(GeneratedVisitor)
13488            }
13489        }
13490        struct GeneratedVisitor;
13491        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13492            type Value = SplitCompactionGroupResponse;
13493
13494            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13495                formatter.write_str("struct hummock.SplitCompactionGroupResponse")
13496            }
13497
13498            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SplitCompactionGroupResponse, V::Error>
13499                where
13500                    V: serde::de::MapAccess<'de>,
13501            {
13502                let mut new_group_id__ = None;
13503                while let Some(k) = map_.next_key()? {
13504                    match k {
13505                        GeneratedField::NewGroupId => {
13506                            if new_group_id__.is_some() {
13507                                return Err(serde::de::Error::duplicate_field("newGroupId"));
13508                            }
13509                            new_group_id__ = 
13510                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13511                            ;
13512                        }
13513                    }
13514                }
13515                Ok(SplitCompactionGroupResponse {
13516                    new_group_id: new_group_id__.unwrap_or_default(),
13517                })
13518            }
13519        }
13520        deserializer.deserialize_struct("hummock.SplitCompactionGroupResponse", FIELDS, GeneratedVisitor)
13521    }
13522}
13523impl serde::Serialize for SstableInfo {
13524    #[allow(deprecated)]
13525    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13526    where
13527        S: serde::Serializer,
13528    {
13529        use serde::ser::SerializeStruct;
13530        let mut len = 0;
13531        if self.object_id != 0 {
13532            len += 1;
13533        }
13534        if self.sst_id != 0 {
13535            len += 1;
13536        }
13537        if self.key_range.is_some() {
13538            len += 1;
13539        }
13540        if self.file_size != 0 {
13541            len += 1;
13542        }
13543        if !self.table_ids.is_empty() {
13544            len += 1;
13545        }
13546        if self.meta_offset != 0 {
13547            len += 1;
13548        }
13549        if self.stale_key_count != 0 {
13550            len += 1;
13551        }
13552        if self.total_key_count != 0 {
13553            len += 1;
13554        }
13555        if self.min_epoch != 0 {
13556            len += 1;
13557        }
13558        if self.max_epoch != 0 {
13559            len += 1;
13560        }
13561        if self.uncompressed_file_size != 0 {
13562            len += 1;
13563        }
13564        if self.range_tombstone_count != 0 {
13565            len += 1;
13566        }
13567        if self.bloom_filter_kind != 0 {
13568            len += 1;
13569        }
13570        if self.sst_size != 0 {
13571            len += 1;
13572        }
13573        let mut struct_ser = serializer.serialize_struct("hummock.SstableInfo", len)?;
13574        if self.object_id != 0 {
13575            #[allow(clippy::needless_borrow)]
13576            #[allow(clippy::needless_borrows_for_generic_args)]
13577            struct_ser.serialize_field("objectId", ToString::to_string(&self.object_id).as_str())?;
13578        }
13579        if self.sst_id != 0 {
13580            #[allow(clippy::needless_borrow)]
13581            #[allow(clippy::needless_borrows_for_generic_args)]
13582            struct_ser.serialize_field("sstId", ToString::to_string(&self.sst_id).as_str())?;
13583        }
13584        if let Some(v) = self.key_range.as_ref() {
13585            struct_ser.serialize_field("keyRange", v)?;
13586        }
13587        if self.file_size != 0 {
13588            #[allow(clippy::needless_borrow)]
13589            #[allow(clippy::needless_borrows_for_generic_args)]
13590            struct_ser.serialize_field("fileSize", ToString::to_string(&self.file_size).as_str())?;
13591        }
13592        if !self.table_ids.is_empty() {
13593            struct_ser.serialize_field("tableIds", &self.table_ids)?;
13594        }
13595        if self.meta_offset != 0 {
13596            #[allow(clippy::needless_borrow)]
13597            #[allow(clippy::needless_borrows_for_generic_args)]
13598            struct_ser.serialize_field("metaOffset", ToString::to_string(&self.meta_offset).as_str())?;
13599        }
13600        if self.stale_key_count != 0 {
13601            #[allow(clippy::needless_borrow)]
13602            #[allow(clippy::needless_borrows_for_generic_args)]
13603            struct_ser.serialize_field("staleKeyCount", ToString::to_string(&self.stale_key_count).as_str())?;
13604        }
13605        if self.total_key_count != 0 {
13606            #[allow(clippy::needless_borrow)]
13607            #[allow(clippy::needless_borrows_for_generic_args)]
13608            struct_ser.serialize_field("totalKeyCount", ToString::to_string(&self.total_key_count).as_str())?;
13609        }
13610        if self.min_epoch != 0 {
13611            #[allow(clippy::needless_borrow)]
13612            #[allow(clippy::needless_borrows_for_generic_args)]
13613            struct_ser.serialize_field("minEpoch", ToString::to_string(&self.min_epoch).as_str())?;
13614        }
13615        if self.max_epoch != 0 {
13616            #[allow(clippy::needless_borrow)]
13617            #[allow(clippy::needless_borrows_for_generic_args)]
13618            struct_ser.serialize_field("maxEpoch", ToString::to_string(&self.max_epoch).as_str())?;
13619        }
13620        if self.uncompressed_file_size != 0 {
13621            #[allow(clippy::needless_borrow)]
13622            #[allow(clippy::needless_borrows_for_generic_args)]
13623            struct_ser.serialize_field("uncompressedFileSize", ToString::to_string(&self.uncompressed_file_size).as_str())?;
13624        }
13625        if self.range_tombstone_count != 0 {
13626            #[allow(clippy::needless_borrow)]
13627            #[allow(clippy::needless_borrows_for_generic_args)]
13628            struct_ser.serialize_field("rangeTombstoneCount", ToString::to_string(&self.range_tombstone_count).as_str())?;
13629        }
13630        if self.bloom_filter_kind != 0 {
13631            let v = BloomFilterType::try_from(self.bloom_filter_kind)
13632                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.bloom_filter_kind)))?;
13633            struct_ser.serialize_field("bloomFilterKind", &v)?;
13634        }
13635        if self.sst_size != 0 {
13636            #[allow(clippy::needless_borrow)]
13637            #[allow(clippy::needless_borrows_for_generic_args)]
13638            struct_ser.serialize_field("sstSize", ToString::to_string(&self.sst_size).as_str())?;
13639        }
13640        struct_ser.end()
13641    }
13642}
13643impl<'de> serde::Deserialize<'de> for SstableInfo {
13644    #[allow(deprecated)]
13645    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13646    where
13647        D: serde::Deserializer<'de>,
13648    {
13649        const FIELDS: &[&str] = &[
13650            "object_id",
13651            "objectId",
13652            "sst_id",
13653            "sstId",
13654            "key_range",
13655            "keyRange",
13656            "file_size",
13657            "fileSize",
13658            "table_ids",
13659            "tableIds",
13660            "meta_offset",
13661            "metaOffset",
13662            "stale_key_count",
13663            "staleKeyCount",
13664            "total_key_count",
13665            "totalKeyCount",
13666            "min_epoch",
13667            "minEpoch",
13668            "max_epoch",
13669            "maxEpoch",
13670            "uncompressed_file_size",
13671            "uncompressedFileSize",
13672            "range_tombstone_count",
13673            "rangeTombstoneCount",
13674            "bloom_filter_kind",
13675            "bloomFilterKind",
13676            "sst_size",
13677            "sstSize",
13678        ];
13679
13680        #[allow(clippy::enum_variant_names)]
13681        enum GeneratedField {
13682            ObjectId,
13683            SstId,
13684            KeyRange,
13685            FileSize,
13686            TableIds,
13687            MetaOffset,
13688            StaleKeyCount,
13689            TotalKeyCount,
13690            MinEpoch,
13691            MaxEpoch,
13692            UncompressedFileSize,
13693            RangeTombstoneCount,
13694            BloomFilterKind,
13695            SstSize,
13696        }
13697        impl<'de> serde::Deserialize<'de> for GeneratedField {
13698            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13699            where
13700                D: serde::Deserializer<'de>,
13701            {
13702                struct GeneratedVisitor;
13703
13704                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13705                    type Value = GeneratedField;
13706
13707                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13708                        write!(formatter, "expected one of: {:?}", &FIELDS)
13709                    }
13710
13711                    #[allow(unused_variables)]
13712                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13713                    where
13714                        E: serde::de::Error,
13715                    {
13716                        match value {
13717                            "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
13718                            "sstId" | "sst_id" => Ok(GeneratedField::SstId),
13719                            "keyRange" | "key_range" => Ok(GeneratedField::KeyRange),
13720                            "fileSize" | "file_size" => Ok(GeneratedField::FileSize),
13721                            "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
13722                            "metaOffset" | "meta_offset" => Ok(GeneratedField::MetaOffset),
13723                            "staleKeyCount" | "stale_key_count" => Ok(GeneratedField::StaleKeyCount),
13724                            "totalKeyCount" | "total_key_count" => Ok(GeneratedField::TotalKeyCount),
13725                            "minEpoch" | "min_epoch" => Ok(GeneratedField::MinEpoch),
13726                            "maxEpoch" | "max_epoch" => Ok(GeneratedField::MaxEpoch),
13727                            "uncompressedFileSize" | "uncompressed_file_size" => Ok(GeneratedField::UncompressedFileSize),
13728                            "rangeTombstoneCount" | "range_tombstone_count" => Ok(GeneratedField::RangeTombstoneCount),
13729                            "bloomFilterKind" | "bloom_filter_kind" => Ok(GeneratedField::BloomFilterKind),
13730                            "sstSize" | "sst_size" => Ok(GeneratedField::SstSize),
13731                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13732                        }
13733                    }
13734                }
13735                deserializer.deserialize_identifier(GeneratedVisitor)
13736            }
13737        }
13738        struct GeneratedVisitor;
13739        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13740            type Value = SstableInfo;
13741
13742            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13743                formatter.write_str("struct hummock.SstableInfo")
13744            }
13745
13746            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SstableInfo, V::Error>
13747                where
13748                    V: serde::de::MapAccess<'de>,
13749            {
13750                let mut object_id__ = None;
13751                let mut sst_id__ = None;
13752                let mut key_range__ = None;
13753                let mut file_size__ = None;
13754                let mut table_ids__ = None;
13755                let mut meta_offset__ = None;
13756                let mut stale_key_count__ = None;
13757                let mut total_key_count__ = None;
13758                let mut min_epoch__ = None;
13759                let mut max_epoch__ = None;
13760                let mut uncompressed_file_size__ = None;
13761                let mut range_tombstone_count__ = None;
13762                let mut bloom_filter_kind__ = None;
13763                let mut sst_size__ = None;
13764                while let Some(k) = map_.next_key()? {
13765                    match k {
13766                        GeneratedField::ObjectId => {
13767                            if object_id__.is_some() {
13768                                return Err(serde::de::Error::duplicate_field("objectId"));
13769                            }
13770                            object_id__ = 
13771                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13772                            ;
13773                        }
13774                        GeneratedField::SstId => {
13775                            if sst_id__.is_some() {
13776                                return Err(serde::de::Error::duplicate_field("sstId"));
13777                            }
13778                            sst_id__ = 
13779                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13780                            ;
13781                        }
13782                        GeneratedField::KeyRange => {
13783                            if key_range__.is_some() {
13784                                return Err(serde::de::Error::duplicate_field("keyRange"));
13785                            }
13786                            key_range__ = map_.next_value()?;
13787                        }
13788                        GeneratedField::FileSize => {
13789                            if file_size__.is_some() {
13790                                return Err(serde::de::Error::duplicate_field("fileSize"));
13791                            }
13792                            file_size__ = 
13793                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13794                            ;
13795                        }
13796                        GeneratedField::TableIds => {
13797                            if table_ids__.is_some() {
13798                                return Err(serde::de::Error::duplicate_field("tableIds"));
13799                            }
13800                            table_ids__ = 
13801                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13802                                    .into_iter().map(|x| x.0).collect())
13803                            ;
13804                        }
13805                        GeneratedField::MetaOffset => {
13806                            if meta_offset__.is_some() {
13807                                return Err(serde::de::Error::duplicate_field("metaOffset"));
13808                            }
13809                            meta_offset__ = 
13810                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13811                            ;
13812                        }
13813                        GeneratedField::StaleKeyCount => {
13814                            if stale_key_count__.is_some() {
13815                                return Err(serde::de::Error::duplicate_field("staleKeyCount"));
13816                            }
13817                            stale_key_count__ = 
13818                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13819                            ;
13820                        }
13821                        GeneratedField::TotalKeyCount => {
13822                            if total_key_count__.is_some() {
13823                                return Err(serde::de::Error::duplicate_field("totalKeyCount"));
13824                            }
13825                            total_key_count__ = 
13826                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13827                            ;
13828                        }
13829                        GeneratedField::MinEpoch => {
13830                            if min_epoch__.is_some() {
13831                                return Err(serde::de::Error::duplicate_field("minEpoch"));
13832                            }
13833                            min_epoch__ = 
13834                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13835                            ;
13836                        }
13837                        GeneratedField::MaxEpoch => {
13838                            if max_epoch__.is_some() {
13839                                return Err(serde::de::Error::duplicate_field("maxEpoch"));
13840                            }
13841                            max_epoch__ = 
13842                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13843                            ;
13844                        }
13845                        GeneratedField::UncompressedFileSize => {
13846                            if uncompressed_file_size__.is_some() {
13847                                return Err(serde::de::Error::duplicate_field("uncompressedFileSize"));
13848                            }
13849                            uncompressed_file_size__ = 
13850                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13851                            ;
13852                        }
13853                        GeneratedField::RangeTombstoneCount => {
13854                            if range_tombstone_count__.is_some() {
13855                                return Err(serde::de::Error::duplicate_field("rangeTombstoneCount"));
13856                            }
13857                            range_tombstone_count__ = 
13858                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13859                            ;
13860                        }
13861                        GeneratedField::BloomFilterKind => {
13862                            if bloom_filter_kind__.is_some() {
13863                                return Err(serde::de::Error::duplicate_field("bloomFilterKind"));
13864                            }
13865                            bloom_filter_kind__ = Some(map_.next_value::<BloomFilterType>()? as i32);
13866                        }
13867                        GeneratedField::SstSize => {
13868                            if sst_size__.is_some() {
13869                                return Err(serde::de::Error::duplicate_field("sstSize"));
13870                            }
13871                            sst_size__ = 
13872                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13873                            ;
13874                        }
13875                    }
13876                }
13877                Ok(SstableInfo {
13878                    object_id: object_id__.unwrap_or_default(),
13879                    sst_id: sst_id__.unwrap_or_default(),
13880                    key_range: key_range__,
13881                    file_size: file_size__.unwrap_or_default(),
13882                    table_ids: table_ids__.unwrap_or_default(),
13883                    meta_offset: meta_offset__.unwrap_or_default(),
13884                    stale_key_count: stale_key_count__.unwrap_or_default(),
13885                    total_key_count: total_key_count__.unwrap_or_default(),
13886                    min_epoch: min_epoch__.unwrap_or_default(),
13887                    max_epoch: max_epoch__.unwrap_or_default(),
13888                    uncompressed_file_size: uncompressed_file_size__.unwrap_or_default(),
13889                    range_tombstone_count: range_tombstone_count__.unwrap_or_default(),
13890                    bloom_filter_kind: bloom_filter_kind__.unwrap_or_default(),
13891                    sst_size: sst_size__.unwrap_or_default(),
13892                })
13893            }
13894        }
13895        deserializer.deserialize_struct("hummock.SstableInfo", FIELDS, GeneratedVisitor)
13896    }
13897}
13898impl serde::Serialize for StateTableInfo {
13899    #[allow(deprecated)]
13900    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13901    where
13902        S: serde::Serializer,
13903    {
13904        use serde::ser::SerializeStruct;
13905        let mut len = 0;
13906        if self.committed_epoch != 0 {
13907            len += 1;
13908        }
13909        if self.compaction_group_id != 0 {
13910            len += 1;
13911        }
13912        let mut struct_ser = serializer.serialize_struct("hummock.StateTableInfo", len)?;
13913        if self.committed_epoch != 0 {
13914            #[allow(clippy::needless_borrow)]
13915            #[allow(clippy::needless_borrows_for_generic_args)]
13916            struct_ser.serialize_field("committedEpoch", ToString::to_string(&self.committed_epoch).as_str())?;
13917        }
13918        if self.compaction_group_id != 0 {
13919            #[allow(clippy::needless_borrow)]
13920            #[allow(clippy::needless_borrows_for_generic_args)]
13921            struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
13922        }
13923        struct_ser.end()
13924    }
13925}
13926impl<'de> serde::Deserialize<'de> for StateTableInfo {
13927    #[allow(deprecated)]
13928    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13929    where
13930        D: serde::Deserializer<'de>,
13931    {
13932        const FIELDS: &[&str] = &[
13933            "committed_epoch",
13934            "committedEpoch",
13935            "compaction_group_id",
13936            "compactionGroupId",
13937        ];
13938
13939        #[allow(clippy::enum_variant_names)]
13940        enum GeneratedField {
13941            CommittedEpoch,
13942            CompactionGroupId,
13943        }
13944        impl<'de> serde::Deserialize<'de> for GeneratedField {
13945            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13946            where
13947                D: serde::Deserializer<'de>,
13948            {
13949                struct GeneratedVisitor;
13950
13951                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13952                    type Value = GeneratedField;
13953
13954                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13955                        write!(formatter, "expected one of: {:?}", &FIELDS)
13956                    }
13957
13958                    #[allow(unused_variables)]
13959                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13960                    where
13961                        E: serde::de::Error,
13962                    {
13963                        match value {
13964                            "committedEpoch" | "committed_epoch" => Ok(GeneratedField::CommittedEpoch),
13965                            "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
13966                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13967                        }
13968                    }
13969                }
13970                deserializer.deserialize_identifier(GeneratedVisitor)
13971            }
13972        }
13973        struct GeneratedVisitor;
13974        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13975            type Value = StateTableInfo;
13976
13977            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13978                formatter.write_str("struct hummock.StateTableInfo")
13979            }
13980
13981            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StateTableInfo, V::Error>
13982                where
13983                    V: serde::de::MapAccess<'de>,
13984            {
13985                let mut committed_epoch__ = None;
13986                let mut compaction_group_id__ = None;
13987                while let Some(k) = map_.next_key()? {
13988                    match k {
13989                        GeneratedField::CommittedEpoch => {
13990                            if committed_epoch__.is_some() {
13991                                return Err(serde::de::Error::duplicate_field("committedEpoch"));
13992                            }
13993                            committed_epoch__ = 
13994                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13995                            ;
13996                        }
13997                        GeneratedField::CompactionGroupId => {
13998                            if compaction_group_id__.is_some() {
13999                                return Err(serde::de::Error::duplicate_field("compactionGroupId"));
14000                            }
14001                            compaction_group_id__ = 
14002                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14003                            ;
14004                        }
14005                    }
14006                }
14007                Ok(StateTableInfo {
14008                    committed_epoch: committed_epoch__.unwrap_or_default(),
14009                    compaction_group_id: compaction_group_id__.unwrap_or_default(),
14010                })
14011            }
14012        }
14013        deserializer.deserialize_struct("hummock.StateTableInfo", FIELDS, GeneratedVisitor)
14014    }
14015}
14016impl serde::Serialize for StateTableInfoDelta {
14017    #[allow(deprecated)]
14018    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14019    where
14020        S: serde::Serializer,
14021    {
14022        use serde::ser::SerializeStruct;
14023        let mut len = 0;
14024        if self.committed_epoch != 0 {
14025            len += 1;
14026        }
14027        if self.compaction_group_id != 0 {
14028            len += 1;
14029        }
14030        let mut struct_ser = serializer.serialize_struct("hummock.StateTableInfoDelta", len)?;
14031        if self.committed_epoch != 0 {
14032            #[allow(clippy::needless_borrow)]
14033            #[allow(clippy::needless_borrows_for_generic_args)]
14034            struct_ser.serialize_field("committedEpoch", ToString::to_string(&self.committed_epoch).as_str())?;
14035        }
14036        if self.compaction_group_id != 0 {
14037            #[allow(clippy::needless_borrow)]
14038            #[allow(clippy::needless_borrows_for_generic_args)]
14039            struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
14040        }
14041        struct_ser.end()
14042    }
14043}
14044impl<'de> serde::Deserialize<'de> for StateTableInfoDelta {
14045    #[allow(deprecated)]
14046    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14047    where
14048        D: serde::Deserializer<'de>,
14049    {
14050        const FIELDS: &[&str] = &[
14051            "committed_epoch",
14052            "committedEpoch",
14053            "compaction_group_id",
14054            "compactionGroupId",
14055        ];
14056
14057        #[allow(clippy::enum_variant_names)]
14058        enum GeneratedField {
14059            CommittedEpoch,
14060            CompactionGroupId,
14061        }
14062        impl<'de> serde::Deserialize<'de> for GeneratedField {
14063            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14064            where
14065                D: serde::Deserializer<'de>,
14066            {
14067                struct GeneratedVisitor;
14068
14069                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14070                    type Value = GeneratedField;
14071
14072                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14073                        write!(formatter, "expected one of: {:?}", &FIELDS)
14074                    }
14075
14076                    #[allow(unused_variables)]
14077                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14078                    where
14079                        E: serde::de::Error,
14080                    {
14081                        match value {
14082                            "committedEpoch" | "committed_epoch" => Ok(GeneratedField::CommittedEpoch),
14083                            "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
14084                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14085                        }
14086                    }
14087                }
14088                deserializer.deserialize_identifier(GeneratedVisitor)
14089            }
14090        }
14091        struct GeneratedVisitor;
14092        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14093            type Value = StateTableInfoDelta;
14094
14095            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14096                formatter.write_str("struct hummock.StateTableInfoDelta")
14097            }
14098
14099            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StateTableInfoDelta, V::Error>
14100                where
14101                    V: serde::de::MapAccess<'de>,
14102            {
14103                let mut committed_epoch__ = None;
14104                let mut compaction_group_id__ = None;
14105                while let Some(k) = map_.next_key()? {
14106                    match k {
14107                        GeneratedField::CommittedEpoch => {
14108                            if committed_epoch__.is_some() {
14109                                return Err(serde::de::Error::duplicate_field("committedEpoch"));
14110                            }
14111                            committed_epoch__ = 
14112                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14113                            ;
14114                        }
14115                        GeneratedField::CompactionGroupId => {
14116                            if compaction_group_id__.is_some() {
14117                                return Err(serde::de::Error::duplicate_field("compactionGroupId"));
14118                            }
14119                            compaction_group_id__ = 
14120                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14121                            ;
14122                        }
14123                    }
14124                }
14125                Ok(StateTableInfoDelta {
14126                    committed_epoch: committed_epoch__.unwrap_or_default(),
14127                    compaction_group_id: compaction_group_id__.unwrap_or_default(),
14128                })
14129            }
14130        }
14131        deserializer.deserialize_struct("hummock.StateTableInfoDelta", FIELDS, GeneratedVisitor)
14132    }
14133}
14134impl serde::Serialize for SubscribeCompactionEventRequest {
14135    #[allow(deprecated)]
14136    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14137    where
14138        S: serde::Serializer,
14139    {
14140        use serde::ser::SerializeStruct;
14141        let mut len = 0;
14142        if self.create_at != 0 {
14143            len += 1;
14144        }
14145        if self.event.is_some() {
14146            len += 1;
14147        }
14148        let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest", len)?;
14149        if self.create_at != 0 {
14150            #[allow(clippy::needless_borrow)]
14151            #[allow(clippy::needless_borrows_for_generic_args)]
14152            struct_ser.serialize_field("createAt", ToString::to_string(&self.create_at).as_str())?;
14153        }
14154        if let Some(v) = self.event.as_ref() {
14155            match v {
14156                subscribe_compaction_event_request::Event::Register(v) => {
14157                    struct_ser.serialize_field("register", v)?;
14158                }
14159                subscribe_compaction_event_request::Event::PullTask(v) => {
14160                    struct_ser.serialize_field("pullTask", v)?;
14161                }
14162                subscribe_compaction_event_request::Event::ReportTask(v) => {
14163                    struct_ser.serialize_field("reportTask", v)?;
14164                }
14165                subscribe_compaction_event_request::Event::HeartBeat(v) => {
14166                    struct_ser.serialize_field("heartBeat", v)?;
14167                }
14168            }
14169        }
14170        struct_ser.end()
14171    }
14172}
14173impl<'de> serde::Deserialize<'de> for SubscribeCompactionEventRequest {
14174    #[allow(deprecated)]
14175    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14176    where
14177        D: serde::Deserializer<'de>,
14178    {
14179        const FIELDS: &[&str] = &[
14180            "create_at",
14181            "createAt",
14182            "register",
14183            "pull_task",
14184            "pullTask",
14185            "report_task",
14186            "reportTask",
14187            "heart_beat",
14188            "heartBeat",
14189        ];
14190
14191        #[allow(clippy::enum_variant_names)]
14192        enum GeneratedField {
14193            CreateAt,
14194            Register,
14195            PullTask,
14196            ReportTask,
14197            HeartBeat,
14198        }
14199        impl<'de> serde::Deserialize<'de> for GeneratedField {
14200            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14201            where
14202                D: serde::Deserializer<'de>,
14203            {
14204                struct GeneratedVisitor;
14205
14206                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14207                    type Value = GeneratedField;
14208
14209                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14210                        write!(formatter, "expected one of: {:?}", &FIELDS)
14211                    }
14212
14213                    #[allow(unused_variables)]
14214                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14215                    where
14216                        E: serde::de::Error,
14217                    {
14218                        match value {
14219                            "createAt" | "create_at" => Ok(GeneratedField::CreateAt),
14220                            "register" => Ok(GeneratedField::Register),
14221                            "pullTask" | "pull_task" => Ok(GeneratedField::PullTask),
14222                            "reportTask" | "report_task" => Ok(GeneratedField::ReportTask),
14223                            "heartBeat" | "heart_beat" => Ok(GeneratedField::HeartBeat),
14224                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14225                        }
14226                    }
14227                }
14228                deserializer.deserialize_identifier(GeneratedVisitor)
14229            }
14230        }
14231        struct GeneratedVisitor;
14232        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14233            type Value = SubscribeCompactionEventRequest;
14234
14235            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14236                formatter.write_str("struct hummock.SubscribeCompactionEventRequest")
14237            }
14238
14239            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeCompactionEventRequest, V::Error>
14240                where
14241                    V: serde::de::MapAccess<'de>,
14242            {
14243                let mut create_at__ = None;
14244                let mut event__ = None;
14245                while let Some(k) = map_.next_key()? {
14246                    match k {
14247                        GeneratedField::CreateAt => {
14248                            if create_at__.is_some() {
14249                                return Err(serde::de::Error::duplicate_field("createAt"));
14250                            }
14251                            create_at__ = 
14252                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14253                            ;
14254                        }
14255                        GeneratedField::Register => {
14256                            if event__.is_some() {
14257                                return Err(serde::de::Error::duplicate_field("register"));
14258                            }
14259                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::Register)
14260;
14261                        }
14262                        GeneratedField::PullTask => {
14263                            if event__.is_some() {
14264                                return Err(serde::de::Error::duplicate_field("pullTask"));
14265                            }
14266                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::PullTask)
14267;
14268                        }
14269                        GeneratedField::ReportTask => {
14270                            if event__.is_some() {
14271                                return Err(serde::de::Error::duplicate_field("reportTask"));
14272                            }
14273                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::ReportTask)
14274;
14275                        }
14276                        GeneratedField::HeartBeat => {
14277                            if event__.is_some() {
14278                                return Err(serde::de::Error::duplicate_field("heartBeat"));
14279                            }
14280                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::HeartBeat)
14281;
14282                        }
14283                    }
14284                }
14285                Ok(SubscribeCompactionEventRequest {
14286                    create_at: create_at__.unwrap_or_default(),
14287                    event: event__,
14288                })
14289            }
14290        }
14291        deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest", FIELDS, GeneratedVisitor)
14292    }
14293}
14294impl serde::Serialize for subscribe_compaction_event_request::HeartBeat {
14295    #[allow(deprecated)]
14296    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14297    where
14298        S: serde::Serializer,
14299    {
14300        use serde::ser::SerializeStruct;
14301        let mut len = 0;
14302        if !self.progress.is_empty() {
14303            len += 1;
14304        }
14305        let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.HeartBeat", len)?;
14306        if !self.progress.is_empty() {
14307            struct_ser.serialize_field("progress", &self.progress)?;
14308        }
14309        struct_ser.end()
14310    }
14311}
14312impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::HeartBeat {
14313    #[allow(deprecated)]
14314    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14315    where
14316        D: serde::Deserializer<'de>,
14317    {
14318        const FIELDS: &[&str] = &[
14319            "progress",
14320        ];
14321
14322        #[allow(clippy::enum_variant_names)]
14323        enum GeneratedField {
14324            Progress,
14325        }
14326        impl<'de> serde::Deserialize<'de> for GeneratedField {
14327            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14328            where
14329                D: serde::Deserializer<'de>,
14330            {
14331                struct GeneratedVisitor;
14332
14333                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14334                    type Value = GeneratedField;
14335
14336                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14337                        write!(formatter, "expected one of: {:?}", &FIELDS)
14338                    }
14339
14340                    #[allow(unused_variables)]
14341                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14342                    where
14343                        E: serde::de::Error,
14344                    {
14345                        match value {
14346                            "progress" => Ok(GeneratedField::Progress),
14347                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14348                        }
14349                    }
14350                }
14351                deserializer.deserialize_identifier(GeneratedVisitor)
14352            }
14353        }
14354        struct GeneratedVisitor;
14355        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14356            type Value = subscribe_compaction_event_request::HeartBeat;
14357
14358            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14359                formatter.write_str("struct hummock.SubscribeCompactionEventRequest.HeartBeat")
14360            }
14361
14362            fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::HeartBeat, V::Error>
14363                where
14364                    V: serde::de::MapAccess<'de>,
14365            {
14366                let mut progress__ = None;
14367                while let Some(k) = map_.next_key()? {
14368                    match k {
14369                        GeneratedField::Progress => {
14370                            if progress__.is_some() {
14371                                return Err(serde::de::Error::duplicate_field("progress"));
14372                            }
14373                            progress__ = Some(map_.next_value()?);
14374                        }
14375                    }
14376                }
14377                Ok(subscribe_compaction_event_request::HeartBeat {
14378                    progress: progress__.unwrap_or_default(),
14379                })
14380            }
14381        }
14382        deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.HeartBeat", FIELDS, GeneratedVisitor)
14383    }
14384}
14385impl serde::Serialize for subscribe_compaction_event_request::PullTask {
14386    #[allow(deprecated)]
14387    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14388    where
14389        S: serde::Serializer,
14390    {
14391        use serde::ser::SerializeStruct;
14392        let mut len = 0;
14393        if self.pull_task_count != 0 {
14394            len += 1;
14395        }
14396        let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.PullTask", len)?;
14397        if self.pull_task_count != 0 {
14398            struct_ser.serialize_field("pullTaskCount", &self.pull_task_count)?;
14399        }
14400        struct_ser.end()
14401    }
14402}
14403impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::PullTask {
14404    #[allow(deprecated)]
14405    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14406    where
14407        D: serde::Deserializer<'de>,
14408    {
14409        const FIELDS: &[&str] = &[
14410            "pull_task_count",
14411            "pullTaskCount",
14412        ];
14413
14414        #[allow(clippy::enum_variant_names)]
14415        enum GeneratedField {
14416            PullTaskCount,
14417        }
14418        impl<'de> serde::Deserialize<'de> for GeneratedField {
14419            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14420            where
14421                D: serde::Deserializer<'de>,
14422            {
14423                struct GeneratedVisitor;
14424
14425                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14426                    type Value = GeneratedField;
14427
14428                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14429                        write!(formatter, "expected one of: {:?}", &FIELDS)
14430                    }
14431
14432                    #[allow(unused_variables)]
14433                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14434                    where
14435                        E: serde::de::Error,
14436                    {
14437                        match value {
14438                            "pullTaskCount" | "pull_task_count" => Ok(GeneratedField::PullTaskCount),
14439                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14440                        }
14441                    }
14442                }
14443                deserializer.deserialize_identifier(GeneratedVisitor)
14444            }
14445        }
14446        struct GeneratedVisitor;
14447        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14448            type Value = subscribe_compaction_event_request::PullTask;
14449
14450            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14451                formatter.write_str("struct hummock.SubscribeCompactionEventRequest.PullTask")
14452            }
14453
14454            fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::PullTask, V::Error>
14455                where
14456                    V: serde::de::MapAccess<'de>,
14457            {
14458                let mut pull_task_count__ = None;
14459                while let Some(k) = map_.next_key()? {
14460                    match k {
14461                        GeneratedField::PullTaskCount => {
14462                            if pull_task_count__.is_some() {
14463                                return Err(serde::de::Error::duplicate_field("pullTaskCount"));
14464                            }
14465                            pull_task_count__ = 
14466                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14467                            ;
14468                        }
14469                    }
14470                }
14471                Ok(subscribe_compaction_event_request::PullTask {
14472                    pull_task_count: pull_task_count__.unwrap_or_default(),
14473                })
14474            }
14475        }
14476        deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.PullTask", FIELDS, GeneratedVisitor)
14477    }
14478}
14479impl serde::Serialize for subscribe_compaction_event_request::Register {
14480    #[allow(deprecated)]
14481    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14482    where
14483        S: serde::Serializer,
14484    {
14485        use serde::ser::SerializeStruct;
14486        let mut len = 0;
14487        if self.context_id != 0 {
14488            len += 1;
14489        }
14490        let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.Register", len)?;
14491        if self.context_id != 0 {
14492            struct_ser.serialize_field("contextId", &self.context_id)?;
14493        }
14494        struct_ser.end()
14495    }
14496}
14497impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::Register {
14498    #[allow(deprecated)]
14499    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14500    where
14501        D: serde::Deserializer<'de>,
14502    {
14503        const FIELDS: &[&str] = &[
14504            "context_id",
14505            "contextId",
14506        ];
14507
14508        #[allow(clippy::enum_variant_names)]
14509        enum GeneratedField {
14510            ContextId,
14511        }
14512        impl<'de> serde::Deserialize<'de> for GeneratedField {
14513            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14514            where
14515                D: serde::Deserializer<'de>,
14516            {
14517                struct GeneratedVisitor;
14518
14519                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14520                    type Value = GeneratedField;
14521
14522                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14523                        write!(formatter, "expected one of: {:?}", &FIELDS)
14524                    }
14525
14526                    #[allow(unused_variables)]
14527                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14528                    where
14529                        E: serde::de::Error,
14530                    {
14531                        match value {
14532                            "contextId" | "context_id" => Ok(GeneratedField::ContextId),
14533                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14534                        }
14535                    }
14536                }
14537                deserializer.deserialize_identifier(GeneratedVisitor)
14538            }
14539        }
14540        struct GeneratedVisitor;
14541        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14542            type Value = subscribe_compaction_event_request::Register;
14543
14544            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14545                formatter.write_str("struct hummock.SubscribeCompactionEventRequest.Register")
14546            }
14547
14548            fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::Register, V::Error>
14549                where
14550                    V: serde::de::MapAccess<'de>,
14551            {
14552                let mut context_id__ = None;
14553                while let Some(k) = map_.next_key()? {
14554                    match k {
14555                        GeneratedField::ContextId => {
14556                            if context_id__.is_some() {
14557                                return Err(serde::de::Error::duplicate_field("contextId"));
14558                            }
14559                            context_id__ = 
14560                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14561                            ;
14562                        }
14563                    }
14564                }
14565                Ok(subscribe_compaction_event_request::Register {
14566                    context_id: context_id__.unwrap_or_default(),
14567                })
14568            }
14569        }
14570        deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.Register", FIELDS, GeneratedVisitor)
14571    }
14572}
14573impl serde::Serialize for subscribe_compaction_event_request::ReportTask {
14574    #[allow(deprecated)]
14575    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14576    where
14577        S: serde::Serializer,
14578    {
14579        use serde::ser::SerializeStruct;
14580        let mut len = 0;
14581        if !self.table_stats_change.is_empty() {
14582            len += 1;
14583        }
14584        if self.task_id != 0 {
14585            len += 1;
14586        }
14587        if self.task_status != 0 {
14588            len += 1;
14589        }
14590        if !self.sorted_output_ssts.is_empty() {
14591            len += 1;
14592        }
14593        if !self.object_timestamps.is_empty() {
14594            len += 1;
14595        }
14596        let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.ReportTask", len)?;
14597        if !self.table_stats_change.is_empty() {
14598            struct_ser.serialize_field("tableStatsChange", &self.table_stats_change)?;
14599        }
14600        if self.task_id != 0 {
14601            #[allow(clippy::needless_borrow)]
14602            #[allow(clippy::needless_borrows_for_generic_args)]
14603            struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
14604        }
14605        if self.task_status != 0 {
14606            let v = compact_task::TaskStatus::try_from(self.task_status)
14607                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.task_status)))?;
14608            struct_ser.serialize_field("taskStatus", &v)?;
14609        }
14610        if !self.sorted_output_ssts.is_empty() {
14611            struct_ser.serialize_field("sortedOutputSsts", &self.sorted_output_ssts)?;
14612        }
14613        if !self.object_timestamps.is_empty() {
14614            let v: std::collections::HashMap<_, _> = self.object_timestamps.iter()
14615                .map(|(k, v)| (k, v.to_string())).collect();
14616            struct_ser.serialize_field("objectTimestamps", &v)?;
14617        }
14618        struct_ser.end()
14619    }
14620}
14621impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::ReportTask {
14622    #[allow(deprecated)]
14623    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14624    where
14625        D: serde::Deserializer<'de>,
14626    {
14627        const FIELDS: &[&str] = &[
14628            "table_stats_change",
14629            "tableStatsChange",
14630            "task_id",
14631            "taskId",
14632            "task_status",
14633            "taskStatus",
14634            "sorted_output_ssts",
14635            "sortedOutputSsts",
14636            "object_timestamps",
14637            "objectTimestamps",
14638        ];
14639
14640        #[allow(clippy::enum_variant_names)]
14641        enum GeneratedField {
14642            TableStatsChange,
14643            TaskId,
14644            TaskStatus,
14645            SortedOutputSsts,
14646            ObjectTimestamps,
14647        }
14648        impl<'de> serde::Deserialize<'de> for GeneratedField {
14649            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14650            where
14651                D: serde::Deserializer<'de>,
14652            {
14653                struct GeneratedVisitor;
14654
14655                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14656                    type Value = GeneratedField;
14657
14658                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14659                        write!(formatter, "expected one of: {:?}", &FIELDS)
14660                    }
14661
14662                    #[allow(unused_variables)]
14663                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14664                    where
14665                        E: serde::de::Error,
14666                    {
14667                        match value {
14668                            "tableStatsChange" | "table_stats_change" => Ok(GeneratedField::TableStatsChange),
14669                            "taskId" | "task_id" => Ok(GeneratedField::TaskId),
14670                            "taskStatus" | "task_status" => Ok(GeneratedField::TaskStatus),
14671                            "sortedOutputSsts" | "sorted_output_ssts" => Ok(GeneratedField::SortedOutputSsts),
14672                            "objectTimestamps" | "object_timestamps" => Ok(GeneratedField::ObjectTimestamps),
14673                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14674                        }
14675                    }
14676                }
14677                deserializer.deserialize_identifier(GeneratedVisitor)
14678            }
14679        }
14680        struct GeneratedVisitor;
14681        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14682            type Value = subscribe_compaction_event_request::ReportTask;
14683
14684            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14685                formatter.write_str("struct hummock.SubscribeCompactionEventRequest.ReportTask")
14686            }
14687
14688            fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::ReportTask, V::Error>
14689                where
14690                    V: serde::de::MapAccess<'de>,
14691            {
14692                let mut table_stats_change__ = None;
14693                let mut task_id__ = None;
14694                let mut task_status__ = None;
14695                let mut sorted_output_ssts__ = None;
14696                let mut object_timestamps__ = None;
14697                while let Some(k) = map_.next_key()? {
14698                    match k {
14699                        GeneratedField::TableStatsChange => {
14700                            if table_stats_change__.is_some() {
14701                                return Err(serde::de::Error::duplicate_field("tableStatsChange"));
14702                            }
14703                            table_stats_change__ = Some(
14704                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14705                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
14706                            );
14707                        }
14708                        GeneratedField::TaskId => {
14709                            if task_id__.is_some() {
14710                                return Err(serde::de::Error::duplicate_field("taskId"));
14711                            }
14712                            task_id__ = 
14713                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14714                            ;
14715                        }
14716                        GeneratedField::TaskStatus => {
14717                            if task_status__.is_some() {
14718                                return Err(serde::de::Error::duplicate_field("taskStatus"));
14719                            }
14720                            task_status__ = Some(map_.next_value::<compact_task::TaskStatus>()? as i32);
14721                        }
14722                        GeneratedField::SortedOutputSsts => {
14723                            if sorted_output_ssts__.is_some() {
14724                                return Err(serde::de::Error::duplicate_field("sortedOutputSsts"));
14725                            }
14726                            sorted_output_ssts__ = Some(map_.next_value()?);
14727                        }
14728                        GeneratedField::ObjectTimestamps => {
14729                            if object_timestamps__.is_some() {
14730                                return Err(serde::de::Error::duplicate_field("objectTimestamps"));
14731                            }
14732                            object_timestamps__ = Some(
14733                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
14734                                    .into_iter().map(|(k,v)| (k.0, v.0)).collect()
14735                            );
14736                        }
14737                    }
14738                }
14739                Ok(subscribe_compaction_event_request::ReportTask {
14740                    table_stats_change: table_stats_change__.unwrap_or_default(),
14741                    task_id: task_id__.unwrap_or_default(),
14742                    task_status: task_status__.unwrap_or_default(),
14743                    sorted_output_ssts: sorted_output_ssts__.unwrap_or_default(),
14744                    object_timestamps: object_timestamps__.unwrap_or_default(),
14745                })
14746            }
14747        }
14748        deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.ReportTask", FIELDS, GeneratedVisitor)
14749    }
14750}
14751impl serde::Serialize for SubscribeCompactionEventResponse {
14752    #[allow(deprecated)]
14753    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14754    where
14755        S: serde::Serializer,
14756    {
14757        use serde::ser::SerializeStruct;
14758        let mut len = 0;
14759        if self.create_at != 0 {
14760            len += 1;
14761        }
14762        if self.event.is_some() {
14763            len += 1;
14764        }
14765        let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventResponse", len)?;
14766        if self.create_at != 0 {
14767            #[allow(clippy::needless_borrow)]
14768            #[allow(clippy::needless_borrows_for_generic_args)]
14769            struct_ser.serialize_field("createAt", ToString::to_string(&self.create_at).as_str())?;
14770        }
14771        if let Some(v) = self.event.as_ref() {
14772            match v {
14773                subscribe_compaction_event_response::Event::CompactTask(v) => {
14774                    struct_ser.serialize_field("compactTask", v)?;
14775                }
14776                subscribe_compaction_event_response::Event::VacuumTask(v) => {
14777                    struct_ser.serialize_field("vacuumTask", v)?;
14778                }
14779                subscribe_compaction_event_response::Event::FullScanTask(v) => {
14780                    struct_ser.serialize_field("fullScanTask", v)?;
14781                }
14782                subscribe_compaction_event_response::Event::ValidationTask(v) => {
14783                    struct_ser.serialize_field("validationTask", v)?;
14784                }
14785                subscribe_compaction_event_response::Event::CancelCompactTask(v) => {
14786                    struct_ser.serialize_field("cancelCompactTask", v)?;
14787                }
14788                subscribe_compaction_event_response::Event::PullTaskAck(v) => {
14789                    struct_ser.serialize_field("pullTaskAck", v)?;
14790                }
14791            }
14792        }
14793        struct_ser.end()
14794    }
14795}
14796impl<'de> serde::Deserialize<'de> for SubscribeCompactionEventResponse {
14797    #[allow(deprecated)]
14798    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14799    where
14800        D: serde::Deserializer<'de>,
14801    {
14802        const FIELDS: &[&str] = &[
14803            "create_at",
14804            "createAt",
14805            "compact_task",
14806            "compactTask",
14807            "vacuum_task",
14808            "vacuumTask",
14809            "full_scan_task",
14810            "fullScanTask",
14811            "validation_task",
14812            "validationTask",
14813            "cancel_compact_task",
14814            "cancelCompactTask",
14815            "pull_task_ack",
14816            "pullTaskAck",
14817        ];
14818
14819        #[allow(clippy::enum_variant_names)]
14820        enum GeneratedField {
14821            CreateAt,
14822            CompactTask,
14823            VacuumTask,
14824            FullScanTask,
14825            ValidationTask,
14826            CancelCompactTask,
14827            PullTaskAck,
14828        }
14829        impl<'de> serde::Deserialize<'de> for GeneratedField {
14830            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14831            where
14832                D: serde::Deserializer<'de>,
14833            {
14834                struct GeneratedVisitor;
14835
14836                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14837                    type Value = GeneratedField;
14838
14839                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14840                        write!(formatter, "expected one of: {:?}", &FIELDS)
14841                    }
14842
14843                    #[allow(unused_variables)]
14844                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14845                    where
14846                        E: serde::de::Error,
14847                    {
14848                        match value {
14849                            "createAt" | "create_at" => Ok(GeneratedField::CreateAt),
14850                            "compactTask" | "compact_task" => Ok(GeneratedField::CompactTask),
14851                            "vacuumTask" | "vacuum_task" => Ok(GeneratedField::VacuumTask),
14852                            "fullScanTask" | "full_scan_task" => Ok(GeneratedField::FullScanTask),
14853                            "validationTask" | "validation_task" => Ok(GeneratedField::ValidationTask),
14854                            "cancelCompactTask" | "cancel_compact_task" => Ok(GeneratedField::CancelCompactTask),
14855                            "pullTaskAck" | "pull_task_ack" => Ok(GeneratedField::PullTaskAck),
14856                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14857                        }
14858                    }
14859                }
14860                deserializer.deserialize_identifier(GeneratedVisitor)
14861            }
14862        }
14863        struct GeneratedVisitor;
14864        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14865            type Value = SubscribeCompactionEventResponse;
14866
14867            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14868                formatter.write_str("struct hummock.SubscribeCompactionEventResponse")
14869            }
14870
14871            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeCompactionEventResponse, V::Error>
14872                where
14873                    V: serde::de::MapAccess<'de>,
14874            {
14875                let mut create_at__ = None;
14876                let mut event__ = None;
14877                while let Some(k) = map_.next_key()? {
14878                    match k {
14879                        GeneratedField::CreateAt => {
14880                            if create_at__.is_some() {
14881                                return Err(serde::de::Error::duplicate_field("createAt"));
14882                            }
14883                            create_at__ = 
14884                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14885                            ;
14886                        }
14887                        GeneratedField::CompactTask => {
14888                            if event__.is_some() {
14889                                return Err(serde::de::Error::duplicate_field("compactTask"));
14890                            }
14891                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::CompactTask)
14892;
14893                        }
14894                        GeneratedField::VacuumTask => {
14895                            if event__.is_some() {
14896                                return Err(serde::de::Error::duplicate_field("vacuumTask"));
14897                            }
14898                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::VacuumTask)
14899;
14900                        }
14901                        GeneratedField::FullScanTask => {
14902                            if event__.is_some() {
14903                                return Err(serde::de::Error::duplicate_field("fullScanTask"));
14904                            }
14905                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::FullScanTask)
14906;
14907                        }
14908                        GeneratedField::ValidationTask => {
14909                            if event__.is_some() {
14910                                return Err(serde::de::Error::duplicate_field("validationTask"));
14911                            }
14912                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::ValidationTask)
14913;
14914                        }
14915                        GeneratedField::CancelCompactTask => {
14916                            if event__.is_some() {
14917                                return Err(serde::de::Error::duplicate_field("cancelCompactTask"));
14918                            }
14919                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::CancelCompactTask)
14920;
14921                        }
14922                        GeneratedField::PullTaskAck => {
14923                            if event__.is_some() {
14924                                return Err(serde::de::Error::duplicate_field("pullTaskAck"));
14925                            }
14926                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::PullTaskAck)
14927;
14928                        }
14929                    }
14930                }
14931                Ok(SubscribeCompactionEventResponse {
14932                    create_at: create_at__.unwrap_or_default(),
14933                    event: event__,
14934                })
14935            }
14936        }
14937        deserializer.deserialize_struct("hummock.SubscribeCompactionEventResponse", FIELDS, GeneratedVisitor)
14938    }
14939}
14940impl serde::Serialize for subscribe_compaction_event_response::PullTaskAck {
14941    #[allow(deprecated)]
14942    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14943    where
14944        S: serde::Serializer,
14945    {
14946        use serde::ser::SerializeStruct;
14947        let len = 0;
14948        let struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventResponse.PullTaskAck", len)?;
14949        struct_ser.end()
14950    }
14951}
14952impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_response::PullTaskAck {
14953    #[allow(deprecated)]
14954    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14955    where
14956        D: serde::Deserializer<'de>,
14957    {
14958        const FIELDS: &[&str] = &[
14959        ];
14960
14961        #[allow(clippy::enum_variant_names)]
14962        enum GeneratedField {
14963        }
14964        impl<'de> serde::Deserialize<'de> for GeneratedField {
14965            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14966            where
14967                D: serde::Deserializer<'de>,
14968            {
14969                struct GeneratedVisitor;
14970
14971                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14972                    type Value = GeneratedField;
14973
14974                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14975                        write!(formatter, "expected one of: {:?}", &FIELDS)
14976                    }
14977
14978                    #[allow(unused_variables)]
14979                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14980                    where
14981                        E: serde::de::Error,
14982                    {
14983                            Err(serde::de::Error::unknown_field(value, FIELDS))
14984                    }
14985                }
14986                deserializer.deserialize_identifier(GeneratedVisitor)
14987            }
14988        }
14989        struct GeneratedVisitor;
14990        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14991            type Value = subscribe_compaction_event_response::PullTaskAck;
14992
14993            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14994                formatter.write_str("struct hummock.SubscribeCompactionEventResponse.PullTaskAck")
14995            }
14996
14997            fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_response::PullTaskAck, V::Error>
14998                where
14999                    V: serde::de::MapAccess<'de>,
15000            {
15001                while map_.next_key::<GeneratedField>()?.is_some() {
15002                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15003                }
15004                Ok(subscribe_compaction_event_response::PullTaskAck {
15005                })
15006            }
15007        }
15008        deserializer.deserialize_struct("hummock.SubscribeCompactionEventResponse.PullTaskAck", FIELDS, GeneratedVisitor)
15009    }
15010}
15011impl serde::Serialize for TableChangeLog {
15012    #[allow(deprecated)]
15013    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15014    where
15015        S: serde::Serializer,
15016    {
15017        use serde::ser::SerializeStruct;
15018        let mut len = 0;
15019        if !self.change_logs.is_empty() {
15020            len += 1;
15021        }
15022        let mut struct_ser = serializer.serialize_struct("hummock.TableChangeLog", len)?;
15023        if !self.change_logs.is_empty() {
15024            struct_ser.serialize_field("changeLogs", &self.change_logs)?;
15025        }
15026        struct_ser.end()
15027    }
15028}
15029impl<'de> serde::Deserialize<'de> for TableChangeLog {
15030    #[allow(deprecated)]
15031    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15032    where
15033        D: serde::Deserializer<'de>,
15034    {
15035        const FIELDS: &[&str] = &[
15036            "change_logs",
15037            "changeLogs",
15038        ];
15039
15040        #[allow(clippy::enum_variant_names)]
15041        enum GeneratedField {
15042            ChangeLogs,
15043        }
15044        impl<'de> serde::Deserialize<'de> for GeneratedField {
15045            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15046            where
15047                D: serde::Deserializer<'de>,
15048            {
15049                struct GeneratedVisitor;
15050
15051                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15052                    type Value = GeneratedField;
15053
15054                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15055                        write!(formatter, "expected one of: {:?}", &FIELDS)
15056                    }
15057
15058                    #[allow(unused_variables)]
15059                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15060                    where
15061                        E: serde::de::Error,
15062                    {
15063                        match value {
15064                            "changeLogs" | "change_logs" => Ok(GeneratedField::ChangeLogs),
15065                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15066                        }
15067                    }
15068                }
15069                deserializer.deserialize_identifier(GeneratedVisitor)
15070            }
15071        }
15072        struct GeneratedVisitor;
15073        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15074            type Value = TableChangeLog;
15075
15076            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15077                formatter.write_str("struct hummock.TableChangeLog")
15078            }
15079
15080            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableChangeLog, V::Error>
15081                where
15082                    V: serde::de::MapAccess<'de>,
15083            {
15084                let mut change_logs__ = None;
15085                while let Some(k) = map_.next_key()? {
15086                    match k {
15087                        GeneratedField::ChangeLogs => {
15088                            if change_logs__.is_some() {
15089                                return Err(serde::de::Error::duplicate_field("changeLogs"));
15090                            }
15091                            change_logs__ = Some(map_.next_value()?);
15092                        }
15093                    }
15094                }
15095                Ok(TableChangeLog {
15096                    change_logs: change_logs__.unwrap_or_default(),
15097                })
15098            }
15099        }
15100        deserializer.deserialize_struct("hummock.TableChangeLog", FIELDS, GeneratedVisitor)
15101    }
15102}
15103impl serde::Serialize for TableOption {
15104    #[allow(deprecated)]
15105    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15106    where
15107        S: serde::Serializer,
15108    {
15109        use serde::ser::SerializeStruct;
15110        let mut len = 0;
15111        if self.retention_seconds.is_some() {
15112            len += 1;
15113        }
15114        let mut struct_ser = serializer.serialize_struct("hummock.TableOption", len)?;
15115        if let Some(v) = self.retention_seconds.as_ref() {
15116            struct_ser.serialize_field("retentionSeconds", v)?;
15117        }
15118        struct_ser.end()
15119    }
15120}
15121impl<'de> serde::Deserialize<'de> for TableOption {
15122    #[allow(deprecated)]
15123    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15124    where
15125        D: serde::Deserializer<'de>,
15126    {
15127        const FIELDS: &[&str] = &[
15128            "retention_seconds",
15129            "retentionSeconds",
15130        ];
15131
15132        #[allow(clippy::enum_variant_names)]
15133        enum GeneratedField {
15134            RetentionSeconds,
15135        }
15136        impl<'de> serde::Deserialize<'de> for GeneratedField {
15137            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15138            where
15139                D: serde::Deserializer<'de>,
15140            {
15141                struct GeneratedVisitor;
15142
15143                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15144                    type Value = GeneratedField;
15145
15146                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15147                        write!(formatter, "expected one of: {:?}", &FIELDS)
15148                    }
15149
15150                    #[allow(unused_variables)]
15151                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15152                    where
15153                        E: serde::de::Error,
15154                    {
15155                        match value {
15156                            "retentionSeconds" | "retention_seconds" => Ok(GeneratedField::RetentionSeconds),
15157                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15158                        }
15159                    }
15160                }
15161                deserializer.deserialize_identifier(GeneratedVisitor)
15162            }
15163        }
15164        struct GeneratedVisitor;
15165        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15166            type Value = TableOption;
15167
15168            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15169                formatter.write_str("struct hummock.TableOption")
15170            }
15171
15172            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableOption, V::Error>
15173                where
15174                    V: serde::de::MapAccess<'de>,
15175            {
15176                let mut retention_seconds__ = None;
15177                while let Some(k) = map_.next_key()? {
15178                    match k {
15179                        GeneratedField::RetentionSeconds => {
15180                            if retention_seconds__.is_some() {
15181                                return Err(serde::de::Error::duplicate_field("retentionSeconds"));
15182                            }
15183                            retention_seconds__ = 
15184                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15185                            ;
15186                        }
15187                    }
15188                }
15189                Ok(TableOption {
15190                    retention_seconds: retention_seconds__,
15191                })
15192            }
15193        }
15194        deserializer.deserialize_struct("hummock.TableOption", FIELDS, GeneratedVisitor)
15195    }
15196}
15197impl serde::Serialize for TableSchema {
15198    #[allow(deprecated)]
15199    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15200    where
15201        S: serde::Serializer,
15202    {
15203        use serde::ser::SerializeStruct;
15204        let mut len = 0;
15205        if !self.column_ids.is_empty() {
15206            len += 1;
15207        }
15208        let mut struct_ser = serializer.serialize_struct("hummock.TableSchema", len)?;
15209        if !self.column_ids.is_empty() {
15210            struct_ser.serialize_field("columnIds", &self.column_ids)?;
15211        }
15212        struct_ser.end()
15213    }
15214}
15215impl<'de> serde::Deserialize<'de> for TableSchema {
15216    #[allow(deprecated)]
15217    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15218    where
15219        D: serde::Deserializer<'de>,
15220    {
15221        const FIELDS: &[&str] = &[
15222            "column_ids",
15223            "columnIds",
15224        ];
15225
15226        #[allow(clippy::enum_variant_names)]
15227        enum GeneratedField {
15228            ColumnIds,
15229        }
15230        impl<'de> serde::Deserialize<'de> for GeneratedField {
15231            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15232            where
15233                D: serde::Deserializer<'de>,
15234            {
15235                struct GeneratedVisitor;
15236
15237                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15238                    type Value = GeneratedField;
15239
15240                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15241                        write!(formatter, "expected one of: {:?}", &FIELDS)
15242                    }
15243
15244                    #[allow(unused_variables)]
15245                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15246                    where
15247                        E: serde::de::Error,
15248                    {
15249                        match value {
15250                            "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
15251                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15252                        }
15253                    }
15254                }
15255                deserializer.deserialize_identifier(GeneratedVisitor)
15256            }
15257        }
15258        struct GeneratedVisitor;
15259        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15260            type Value = TableSchema;
15261
15262            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15263                formatter.write_str("struct hummock.TableSchema")
15264            }
15265
15266            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableSchema, V::Error>
15267                where
15268                    V: serde::de::MapAccess<'de>,
15269            {
15270                let mut column_ids__ = None;
15271                while let Some(k) = map_.next_key()? {
15272                    match k {
15273                        GeneratedField::ColumnIds => {
15274                            if column_ids__.is_some() {
15275                                return Err(serde::de::Error::duplicate_field("columnIds"));
15276                            }
15277                            column_ids__ = 
15278                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15279                                    .into_iter().map(|x| x.0).collect())
15280                            ;
15281                        }
15282                    }
15283                }
15284                Ok(TableSchema {
15285                    column_ids: column_ids__.unwrap_or_default(),
15286                })
15287            }
15288        }
15289        deserializer.deserialize_struct("hummock.TableSchema", FIELDS, GeneratedVisitor)
15290    }
15291}
15292impl serde::Serialize for TableStats {
15293    #[allow(deprecated)]
15294    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15295    where
15296        S: serde::Serializer,
15297    {
15298        use serde::ser::SerializeStruct;
15299        let mut len = 0;
15300        if self.total_key_size != 0 {
15301            len += 1;
15302        }
15303        if self.total_value_size != 0 {
15304            len += 1;
15305        }
15306        if self.total_key_count != 0 {
15307            len += 1;
15308        }
15309        if self.total_compressed_size != 0 {
15310            len += 1;
15311        }
15312        let mut struct_ser = serializer.serialize_struct("hummock.TableStats", len)?;
15313        if self.total_key_size != 0 {
15314            #[allow(clippy::needless_borrow)]
15315            #[allow(clippy::needless_borrows_for_generic_args)]
15316            struct_ser.serialize_field("totalKeySize", ToString::to_string(&self.total_key_size).as_str())?;
15317        }
15318        if self.total_value_size != 0 {
15319            #[allow(clippy::needless_borrow)]
15320            #[allow(clippy::needless_borrows_for_generic_args)]
15321            struct_ser.serialize_field("totalValueSize", ToString::to_string(&self.total_value_size).as_str())?;
15322        }
15323        if self.total_key_count != 0 {
15324            #[allow(clippy::needless_borrow)]
15325            #[allow(clippy::needless_borrows_for_generic_args)]
15326            struct_ser.serialize_field("totalKeyCount", ToString::to_string(&self.total_key_count).as_str())?;
15327        }
15328        if self.total_compressed_size != 0 {
15329            #[allow(clippy::needless_borrow)]
15330            #[allow(clippy::needless_borrows_for_generic_args)]
15331            struct_ser.serialize_field("totalCompressedSize", ToString::to_string(&self.total_compressed_size).as_str())?;
15332        }
15333        struct_ser.end()
15334    }
15335}
15336impl<'de> serde::Deserialize<'de> for TableStats {
15337    #[allow(deprecated)]
15338    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15339    where
15340        D: serde::Deserializer<'de>,
15341    {
15342        const FIELDS: &[&str] = &[
15343            "total_key_size",
15344            "totalKeySize",
15345            "total_value_size",
15346            "totalValueSize",
15347            "total_key_count",
15348            "totalKeyCount",
15349            "total_compressed_size",
15350            "totalCompressedSize",
15351        ];
15352
15353        #[allow(clippy::enum_variant_names)]
15354        enum GeneratedField {
15355            TotalKeySize,
15356            TotalValueSize,
15357            TotalKeyCount,
15358            TotalCompressedSize,
15359        }
15360        impl<'de> serde::Deserialize<'de> for GeneratedField {
15361            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15362            where
15363                D: serde::Deserializer<'de>,
15364            {
15365                struct GeneratedVisitor;
15366
15367                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15368                    type Value = GeneratedField;
15369
15370                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15371                        write!(formatter, "expected one of: {:?}", &FIELDS)
15372                    }
15373
15374                    #[allow(unused_variables)]
15375                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15376                    where
15377                        E: serde::de::Error,
15378                    {
15379                        match value {
15380                            "totalKeySize" | "total_key_size" => Ok(GeneratedField::TotalKeySize),
15381                            "totalValueSize" | "total_value_size" => Ok(GeneratedField::TotalValueSize),
15382                            "totalKeyCount" | "total_key_count" => Ok(GeneratedField::TotalKeyCount),
15383                            "totalCompressedSize" | "total_compressed_size" => Ok(GeneratedField::TotalCompressedSize),
15384                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15385                        }
15386                    }
15387                }
15388                deserializer.deserialize_identifier(GeneratedVisitor)
15389            }
15390        }
15391        struct GeneratedVisitor;
15392        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15393            type Value = TableStats;
15394
15395            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15396                formatter.write_str("struct hummock.TableStats")
15397            }
15398
15399            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableStats, V::Error>
15400                where
15401                    V: serde::de::MapAccess<'de>,
15402            {
15403                let mut total_key_size__ = None;
15404                let mut total_value_size__ = None;
15405                let mut total_key_count__ = None;
15406                let mut total_compressed_size__ = None;
15407                while let Some(k) = map_.next_key()? {
15408                    match k {
15409                        GeneratedField::TotalKeySize => {
15410                            if total_key_size__.is_some() {
15411                                return Err(serde::de::Error::duplicate_field("totalKeySize"));
15412                            }
15413                            total_key_size__ = 
15414                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15415                            ;
15416                        }
15417                        GeneratedField::TotalValueSize => {
15418                            if total_value_size__.is_some() {
15419                                return Err(serde::de::Error::duplicate_field("totalValueSize"));
15420                            }
15421                            total_value_size__ = 
15422                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15423                            ;
15424                        }
15425                        GeneratedField::TotalKeyCount => {
15426                            if total_key_count__.is_some() {
15427                                return Err(serde::de::Error::duplicate_field("totalKeyCount"));
15428                            }
15429                            total_key_count__ = 
15430                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15431                            ;
15432                        }
15433                        GeneratedField::TotalCompressedSize => {
15434                            if total_compressed_size__.is_some() {
15435                                return Err(serde::de::Error::duplicate_field("totalCompressedSize"));
15436                            }
15437                            total_compressed_size__ = 
15438                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15439                            ;
15440                        }
15441                    }
15442                }
15443                Ok(TableStats {
15444                    total_key_size: total_key_size__.unwrap_or_default(),
15445                    total_value_size: total_value_size__.unwrap_or_default(),
15446                    total_key_count: total_key_count__.unwrap_or_default(),
15447                    total_compressed_size: total_compressed_size__.unwrap_or_default(),
15448                })
15449            }
15450        }
15451        deserializer.deserialize_struct("hummock.TableStats", FIELDS, GeneratedVisitor)
15452    }
15453}
15454impl serde::Serialize for TableWatermarks {
15455    #[allow(deprecated)]
15456    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15457    where
15458        S: serde::Serializer,
15459    {
15460        use serde::ser::SerializeStruct;
15461        let mut len = 0;
15462        if !self.epoch_watermarks.is_empty() {
15463            len += 1;
15464        }
15465        if self.is_ascending {
15466            len += 1;
15467        }
15468        if self.is_non_pk_prefix {
15469            len += 1;
15470        }
15471        let mut struct_ser = serializer.serialize_struct("hummock.TableWatermarks", len)?;
15472        if !self.epoch_watermarks.is_empty() {
15473            struct_ser.serialize_field("epochWatermarks", &self.epoch_watermarks)?;
15474        }
15475        if self.is_ascending {
15476            struct_ser.serialize_field("isAscending", &self.is_ascending)?;
15477        }
15478        if self.is_non_pk_prefix {
15479            struct_ser.serialize_field("isNonPkPrefix", &self.is_non_pk_prefix)?;
15480        }
15481        struct_ser.end()
15482    }
15483}
15484impl<'de> serde::Deserialize<'de> for TableWatermarks {
15485    #[allow(deprecated)]
15486    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15487    where
15488        D: serde::Deserializer<'de>,
15489    {
15490        const FIELDS: &[&str] = &[
15491            "epoch_watermarks",
15492            "epochWatermarks",
15493            "is_ascending",
15494            "isAscending",
15495            "is_non_pk_prefix",
15496            "isNonPkPrefix",
15497        ];
15498
15499        #[allow(clippy::enum_variant_names)]
15500        enum GeneratedField {
15501            EpochWatermarks,
15502            IsAscending,
15503            IsNonPkPrefix,
15504        }
15505        impl<'de> serde::Deserialize<'de> for GeneratedField {
15506            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15507            where
15508                D: serde::Deserializer<'de>,
15509            {
15510                struct GeneratedVisitor;
15511
15512                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15513                    type Value = GeneratedField;
15514
15515                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15516                        write!(formatter, "expected one of: {:?}", &FIELDS)
15517                    }
15518
15519                    #[allow(unused_variables)]
15520                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15521                    where
15522                        E: serde::de::Error,
15523                    {
15524                        match value {
15525                            "epochWatermarks" | "epoch_watermarks" => Ok(GeneratedField::EpochWatermarks),
15526                            "isAscending" | "is_ascending" => Ok(GeneratedField::IsAscending),
15527                            "isNonPkPrefix" | "is_non_pk_prefix" => Ok(GeneratedField::IsNonPkPrefix),
15528                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15529                        }
15530                    }
15531                }
15532                deserializer.deserialize_identifier(GeneratedVisitor)
15533            }
15534        }
15535        struct GeneratedVisitor;
15536        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15537            type Value = TableWatermarks;
15538
15539            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15540                formatter.write_str("struct hummock.TableWatermarks")
15541            }
15542
15543            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableWatermarks, V::Error>
15544                where
15545                    V: serde::de::MapAccess<'de>,
15546            {
15547                let mut epoch_watermarks__ = None;
15548                let mut is_ascending__ = None;
15549                let mut is_non_pk_prefix__ = None;
15550                while let Some(k) = map_.next_key()? {
15551                    match k {
15552                        GeneratedField::EpochWatermarks => {
15553                            if epoch_watermarks__.is_some() {
15554                                return Err(serde::de::Error::duplicate_field("epochWatermarks"));
15555                            }
15556                            epoch_watermarks__ = Some(map_.next_value()?);
15557                        }
15558                        GeneratedField::IsAscending => {
15559                            if is_ascending__.is_some() {
15560                                return Err(serde::de::Error::duplicate_field("isAscending"));
15561                            }
15562                            is_ascending__ = Some(map_.next_value()?);
15563                        }
15564                        GeneratedField::IsNonPkPrefix => {
15565                            if is_non_pk_prefix__.is_some() {
15566                                return Err(serde::de::Error::duplicate_field("isNonPkPrefix"));
15567                            }
15568                            is_non_pk_prefix__ = Some(map_.next_value()?);
15569                        }
15570                    }
15571                }
15572                Ok(TableWatermarks {
15573                    epoch_watermarks: epoch_watermarks__.unwrap_or_default(),
15574                    is_ascending: is_ascending__.unwrap_or_default(),
15575                    is_non_pk_prefix: is_non_pk_prefix__.unwrap_or_default(),
15576                })
15577            }
15578        }
15579        deserializer.deserialize_struct("hummock.TableWatermarks", FIELDS, GeneratedVisitor)
15580    }
15581}
15582impl serde::Serialize for table_watermarks::EpochNewWatermarks {
15583    #[allow(deprecated)]
15584    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15585    where
15586        S: serde::Serializer,
15587    {
15588        use serde::ser::SerializeStruct;
15589        let mut len = 0;
15590        if !self.watermarks.is_empty() {
15591            len += 1;
15592        }
15593        if self.epoch != 0 {
15594            len += 1;
15595        }
15596        let mut struct_ser = serializer.serialize_struct("hummock.TableWatermarks.EpochNewWatermarks", len)?;
15597        if !self.watermarks.is_empty() {
15598            struct_ser.serialize_field("watermarks", &self.watermarks)?;
15599        }
15600        if self.epoch != 0 {
15601            #[allow(clippy::needless_borrow)]
15602            #[allow(clippy::needless_borrows_for_generic_args)]
15603            struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
15604        }
15605        struct_ser.end()
15606    }
15607}
15608impl<'de> serde::Deserialize<'de> for table_watermarks::EpochNewWatermarks {
15609    #[allow(deprecated)]
15610    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15611    where
15612        D: serde::Deserializer<'de>,
15613    {
15614        const FIELDS: &[&str] = &[
15615            "watermarks",
15616            "epoch",
15617        ];
15618
15619        #[allow(clippy::enum_variant_names)]
15620        enum GeneratedField {
15621            Watermarks,
15622            Epoch,
15623        }
15624        impl<'de> serde::Deserialize<'de> for GeneratedField {
15625            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15626            where
15627                D: serde::Deserializer<'de>,
15628            {
15629                struct GeneratedVisitor;
15630
15631                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15632                    type Value = GeneratedField;
15633
15634                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15635                        write!(formatter, "expected one of: {:?}", &FIELDS)
15636                    }
15637
15638                    #[allow(unused_variables)]
15639                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15640                    where
15641                        E: serde::de::Error,
15642                    {
15643                        match value {
15644                            "watermarks" => Ok(GeneratedField::Watermarks),
15645                            "epoch" => Ok(GeneratedField::Epoch),
15646                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15647                        }
15648                    }
15649                }
15650                deserializer.deserialize_identifier(GeneratedVisitor)
15651            }
15652        }
15653        struct GeneratedVisitor;
15654        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15655            type Value = table_watermarks::EpochNewWatermarks;
15656
15657            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15658                formatter.write_str("struct hummock.TableWatermarks.EpochNewWatermarks")
15659            }
15660
15661            fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_watermarks::EpochNewWatermarks, V::Error>
15662                where
15663                    V: serde::de::MapAccess<'de>,
15664            {
15665                let mut watermarks__ = None;
15666                let mut epoch__ = None;
15667                while let Some(k) = map_.next_key()? {
15668                    match k {
15669                        GeneratedField::Watermarks => {
15670                            if watermarks__.is_some() {
15671                                return Err(serde::de::Error::duplicate_field("watermarks"));
15672                            }
15673                            watermarks__ = Some(map_.next_value()?);
15674                        }
15675                        GeneratedField::Epoch => {
15676                            if epoch__.is_some() {
15677                                return Err(serde::de::Error::duplicate_field("epoch"));
15678                            }
15679                            epoch__ = 
15680                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15681                            ;
15682                        }
15683                    }
15684                }
15685                Ok(table_watermarks::EpochNewWatermarks {
15686                    watermarks: watermarks__.unwrap_or_default(),
15687                    epoch: epoch__.unwrap_or_default(),
15688                })
15689            }
15690        }
15691        deserializer.deserialize_struct("hummock.TableWatermarks.EpochNewWatermarks", FIELDS, GeneratedVisitor)
15692    }
15693}
15694impl serde::Serialize for TriggerCompactionDeterministicRequest {
15695    #[allow(deprecated)]
15696    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15697    where
15698        S: serde::Serializer,
15699    {
15700        use serde::ser::SerializeStruct;
15701        let mut len = 0;
15702        if self.version_id != 0 {
15703            len += 1;
15704        }
15705        if !self.compaction_groups.is_empty() {
15706            len += 1;
15707        }
15708        let mut struct_ser = serializer.serialize_struct("hummock.TriggerCompactionDeterministicRequest", len)?;
15709        if self.version_id != 0 {
15710            #[allow(clippy::needless_borrow)]
15711            #[allow(clippy::needless_borrows_for_generic_args)]
15712            struct_ser.serialize_field("versionId", ToString::to_string(&self.version_id).as_str())?;
15713        }
15714        if !self.compaction_groups.is_empty() {
15715            struct_ser.serialize_field("compactionGroups", &self.compaction_groups.iter().map(ToString::to_string).collect::<Vec<_>>())?;
15716        }
15717        struct_ser.end()
15718    }
15719}
15720impl<'de> serde::Deserialize<'de> for TriggerCompactionDeterministicRequest {
15721    #[allow(deprecated)]
15722    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15723    where
15724        D: serde::Deserializer<'de>,
15725    {
15726        const FIELDS: &[&str] = &[
15727            "version_id",
15728            "versionId",
15729            "compaction_groups",
15730            "compactionGroups",
15731        ];
15732
15733        #[allow(clippy::enum_variant_names)]
15734        enum GeneratedField {
15735            VersionId,
15736            CompactionGroups,
15737        }
15738        impl<'de> serde::Deserialize<'de> for GeneratedField {
15739            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15740            where
15741                D: serde::Deserializer<'de>,
15742            {
15743                struct GeneratedVisitor;
15744
15745                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15746                    type Value = GeneratedField;
15747
15748                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15749                        write!(formatter, "expected one of: {:?}", &FIELDS)
15750                    }
15751
15752                    #[allow(unused_variables)]
15753                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15754                    where
15755                        E: serde::de::Error,
15756                    {
15757                        match value {
15758                            "versionId" | "version_id" => Ok(GeneratedField::VersionId),
15759                            "compactionGroups" | "compaction_groups" => Ok(GeneratedField::CompactionGroups),
15760                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15761                        }
15762                    }
15763                }
15764                deserializer.deserialize_identifier(GeneratedVisitor)
15765            }
15766        }
15767        struct GeneratedVisitor;
15768        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15769            type Value = TriggerCompactionDeterministicRequest;
15770
15771            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15772                formatter.write_str("struct hummock.TriggerCompactionDeterministicRequest")
15773            }
15774
15775            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerCompactionDeterministicRequest, V::Error>
15776                where
15777                    V: serde::de::MapAccess<'de>,
15778            {
15779                let mut version_id__ = None;
15780                let mut compaction_groups__ = None;
15781                while let Some(k) = map_.next_key()? {
15782                    match k {
15783                        GeneratedField::VersionId => {
15784                            if version_id__.is_some() {
15785                                return Err(serde::de::Error::duplicate_field("versionId"));
15786                            }
15787                            version_id__ = 
15788                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15789                            ;
15790                        }
15791                        GeneratedField::CompactionGroups => {
15792                            if compaction_groups__.is_some() {
15793                                return Err(serde::de::Error::duplicate_field("compactionGroups"));
15794                            }
15795                            compaction_groups__ = 
15796                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15797                                    .into_iter().map(|x| x.0).collect())
15798                            ;
15799                        }
15800                    }
15801                }
15802                Ok(TriggerCompactionDeterministicRequest {
15803                    version_id: version_id__.unwrap_or_default(),
15804                    compaction_groups: compaction_groups__.unwrap_or_default(),
15805                })
15806            }
15807        }
15808        deserializer.deserialize_struct("hummock.TriggerCompactionDeterministicRequest", FIELDS, GeneratedVisitor)
15809    }
15810}
15811impl serde::Serialize for TriggerCompactionDeterministicResponse {
15812    #[allow(deprecated)]
15813    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15814    where
15815        S: serde::Serializer,
15816    {
15817        use serde::ser::SerializeStruct;
15818        let len = 0;
15819        let struct_ser = serializer.serialize_struct("hummock.TriggerCompactionDeterministicResponse", len)?;
15820        struct_ser.end()
15821    }
15822}
15823impl<'de> serde::Deserialize<'de> for TriggerCompactionDeterministicResponse {
15824    #[allow(deprecated)]
15825    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15826    where
15827        D: serde::Deserializer<'de>,
15828    {
15829        const FIELDS: &[&str] = &[
15830        ];
15831
15832        #[allow(clippy::enum_variant_names)]
15833        enum GeneratedField {
15834        }
15835        impl<'de> serde::Deserialize<'de> for GeneratedField {
15836            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15837            where
15838                D: serde::Deserializer<'de>,
15839            {
15840                struct GeneratedVisitor;
15841
15842                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15843                    type Value = GeneratedField;
15844
15845                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15846                        write!(formatter, "expected one of: {:?}", &FIELDS)
15847                    }
15848
15849                    #[allow(unused_variables)]
15850                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15851                    where
15852                        E: serde::de::Error,
15853                    {
15854                            Err(serde::de::Error::unknown_field(value, FIELDS))
15855                    }
15856                }
15857                deserializer.deserialize_identifier(GeneratedVisitor)
15858            }
15859        }
15860        struct GeneratedVisitor;
15861        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15862            type Value = TriggerCompactionDeterministicResponse;
15863
15864            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15865                formatter.write_str("struct hummock.TriggerCompactionDeterministicResponse")
15866            }
15867
15868            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerCompactionDeterministicResponse, V::Error>
15869                where
15870                    V: serde::de::MapAccess<'de>,
15871            {
15872                while map_.next_key::<GeneratedField>()?.is_some() {
15873                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15874                }
15875                Ok(TriggerCompactionDeterministicResponse {
15876                })
15877            }
15878        }
15879        deserializer.deserialize_struct("hummock.TriggerCompactionDeterministicResponse", FIELDS, GeneratedVisitor)
15880    }
15881}
15882impl serde::Serialize for TriggerFullGcRequest {
15883    #[allow(deprecated)]
15884    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15885    where
15886        S: serde::Serializer,
15887    {
15888        use serde::ser::SerializeStruct;
15889        let mut len = 0;
15890        if self.sst_retention_time_sec != 0 {
15891            len += 1;
15892        }
15893        if self.prefix.is_some() {
15894            len += 1;
15895        }
15896        let mut struct_ser = serializer.serialize_struct("hummock.TriggerFullGCRequest", len)?;
15897        if self.sst_retention_time_sec != 0 {
15898            #[allow(clippy::needless_borrow)]
15899            #[allow(clippy::needless_borrows_for_generic_args)]
15900            struct_ser.serialize_field("sstRetentionTimeSec", ToString::to_string(&self.sst_retention_time_sec).as_str())?;
15901        }
15902        if let Some(v) = self.prefix.as_ref() {
15903            struct_ser.serialize_field("prefix", v)?;
15904        }
15905        struct_ser.end()
15906    }
15907}
15908impl<'de> serde::Deserialize<'de> for TriggerFullGcRequest {
15909    #[allow(deprecated)]
15910    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15911    where
15912        D: serde::Deserializer<'de>,
15913    {
15914        const FIELDS: &[&str] = &[
15915            "sst_retention_time_sec",
15916            "sstRetentionTimeSec",
15917            "prefix",
15918        ];
15919
15920        #[allow(clippy::enum_variant_names)]
15921        enum GeneratedField {
15922            SstRetentionTimeSec,
15923            Prefix,
15924        }
15925        impl<'de> serde::Deserialize<'de> for GeneratedField {
15926            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15927            where
15928                D: serde::Deserializer<'de>,
15929            {
15930                struct GeneratedVisitor;
15931
15932                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15933                    type Value = GeneratedField;
15934
15935                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15936                        write!(formatter, "expected one of: {:?}", &FIELDS)
15937                    }
15938
15939                    #[allow(unused_variables)]
15940                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15941                    where
15942                        E: serde::de::Error,
15943                    {
15944                        match value {
15945                            "sstRetentionTimeSec" | "sst_retention_time_sec" => Ok(GeneratedField::SstRetentionTimeSec),
15946                            "prefix" => Ok(GeneratedField::Prefix),
15947                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15948                        }
15949                    }
15950                }
15951                deserializer.deserialize_identifier(GeneratedVisitor)
15952            }
15953        }
15954        struct GeneratedVisitor;
15955        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15956            type Value = TriggerFullGcRequest;
15957
15958            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15959                formatter.write_str("struct hummock.TriggerFullGCRequest")
15960            }
15961
15962            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerFullGcRequest, V::Error>
15963                where
15964                    V: serde::de::MapAccess<'de>,
15965            {
15966                let mut sst_retention_time_sec__ = None;
15967                let mut prefix__ = None;
15968                while let Some(k) = map_.next_key()? {
15969                    match k {
15970                        GeneratedField::SstRetentionTimeSec => {
15971                            if sst_retention_time_sec__.is_some() {
15972                                return Err(serde::de::Error::duplicate_field("sstRetentionTimeSec"));
15973                            }
15974                            sst_retention_time_sec__ = 
15975                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15976                            ;
15977                        }
15978                        GeneratedField::Prefix => {
15979                            if prefix__.is_some() {
15980                                return Err(serde::de::Error::duplicate_field("prefix"));
15981                            }
15982                            prefix__ = map_.next_value()?;
15983                        }
15984                    }
15985                }
15986                Ok(TriggerFullGcRequest {
15987                    sst_retention_time_sec: sst_retention_time_sec__.unwrap_or_default(),
15988                    prefix: prefix__,
15989                })
15990            }
15991        }
15992        deserializer.deserialize_struct("hummock.TriggerFullGCRequest", FIELDS, GeneratedVisitor)
15993    }
15994}
15995impl serde::Serialize for TriggerFullGcResponse {
15996    #[allow(deprecated)]
15997    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15998    where
15999        S: serde::Serializer,
16000    {
16001        use serde::ser::SerializeStruct;
16002        let mut len = 0;
16003        if self.status.is_some() {
16004            len += 1;
16005        }
16006        let mut struct_ser = serializer.serialize_struct("hummock.TriggerFullGCResponse", len)?;
16007        if let Some(v) = self.status.as_ref() {
16008            struct_ser.serialize_field("status", v)?;
16009        }
16010        struct_ser.end()
16011    }
16012}
16013impl<'de> serde::Deserialize<'de> for TriggerFullGcResponse {
16014    #[allow(deprecated)]
16015    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16016    where
16017        D: serde::Deserializer<'de>,
16018    {
16019        const FIELDS: &[&str] = &[
16020            "status",
16021        ];
16022
16023        #[allow(clippy::enum_variant_names)]
16024        enum GeneratedField {
16025            Status,
16026        }
16027        impl<'de> serde::Deserialize<'de> for GeneratedField {
16028            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16029            where
16030                D: serde::Deserializer<'de>,
16031            {
16032                struct GeneratedVisitor;
16033
16034                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16035                    type Value = GeneratedField;
16036
16037                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16038                        write!(formatter, "expected one of: {:?}", &FIELDS)
16039                    }
16040
16041                    #[allow(unused_variables)]
16042                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16043                    where
16044                        E: serde::de::Error,
16045                    {
16046                        match value {
16047                            "status" => Ok(GeneratedField::Status),
16048                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16049                        }
16050                    }
16051                }
16052                deserializer.deserialize_identifier(GeneratedVisitor)
16053            }
16054        }
16055        struct GeneratedVisitor;
16056        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16057            type Value = TriggerFullGcResponse;
16058
16059            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16060                formatter.write_str("struct hummock.TriggerFullGCResponse")
16061            }
16062
16063            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerFullGcResponse, V::Error>
16064                where
16065                    V: serde::de::MapAccess<'de>,
16066            {
16067                let mut status__ = None;
16068                while let Some(k) = map_.next_key()? {
16069                    match k {
16070                        GeneratedField::Status => {
16071                            if status__.is_some() {
16072                                return Err(serde::de::Error::duplicate_field("status"));
16073                            }
16074                            status__ = map_.next_value()?;
16075                        }
16076                    }
16077                }
16078                Ok(TriggerFullGcResponse {
16079                    status: status__,
16080                })
16081            }
16082        }
16083        deserializer.deserialize_struct("hummock.TriggerFullGCResponse", FIELDS, GeneratedVisitor)
16084    }
16085}
16086impl serde::Serialize for TriggerManualCompactionRequest {
16087    #[allow(deprecated)]
16088    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16089    where
16090        S: serde::Serializer,
16091    {
16092        use serde::ser::SerializeStruct;
16093        let mut len = 0;
16094        if self.compaction_group_id != 0 {
16095            len += 1;
16096        }
16097        if self.key_range.is_some() {
16098            len += 1;
16099        }
16100        if self.table_id != 0 {
16101            len += 1;
16102        }
16103        if self.level != 0 {
16104            len += 1;
16105        }
16106        if !self.sst_ids.is_empty() {
16107            len += 1;
16108        }
16109        let mut struct_ser = serializer.serialize_struct("hummock.TriggerManualCompactionRequest", len)?;
16110        if self.compaction_group_id != 0 {
16111            #[allow(clippy::needless_borrow)]
16112            #[allow(clippy::needless_borrows_for_generic_args)]
16113            struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
16114        }
16115        if let Some(v) = self.key_range.as_ref() {
16116            struct_ser.serialize_field("keyRange", v)?;
16117        }
16118        if self.table_id != 0 {
16119            struct_ser.serialize_field("tableId", &self.table_id)?;
16120        }
16121        if self.level != 0 {
16122            struct_ser.serialize_field("level", &self.level)?;
16123        }
16124        if !self.sst_ids.is_empty() {
16125            struct_ser.serialize_field("sstIds", &self.sst_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
16126        }
16127        struct_ser.end()
16128    }
16129}
16130impl<'de> serde::Deserialize<'de> for TriggerManualCompactionRequest {
16131    #[allow(deprecated)]
16132    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16133    where
16134        D: serde::Deserializer<'de>,
16135    {
16136        const FIELDS: &[&str] = &[
16137            "compaction_group_id",
16138            "compactionGroupId",
16139            "key_range",
16140            "keyRange",
16141            "table_id",
16142            "tableId",
16143            "level",
16144            "sst_ids",
16145            "sstIds",
16146        ];
16147
16148        #[allow(clippy::enum_variant_names)]
16149        enum GeneratedField {
16150            CompactionGroupId,
16151            KeyRange,
16152            TableId,
16153            Level,
16154            SstIds,
16155        }
16156        impl<'de> serde::Deserialize<'de> for GeneratedField {
16157            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16158            where
16159                D: serde::Deserializer<'de>,
16160            {
16161                struct GeneratedVisitor;
16162
16163                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16164                    type Value = GeneratedField;
16165
16166                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16167                        write!(formatter, "expected one of: {:?}", &FIELDS)
16168                    }
16169
16170                    #[allow(unused_variables)]
16171                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16172                    where
16173                        E: serde::de::Error,
16174                    {
16175                        match value {
16176                            "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
16177                            "keyRange" | "key_range" => Ok(GeneratedField::KeyRange),
16178                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
16179                            "level" => Ok(GeneratedField::Level),
16180                            "sstIds" | "sst_ids" => Ok(GeneratedField::SstIds),
16181                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16182                        }
16183                    }
16184                }
16185                deserializer.deserialize_identifier(GeneratedVisitor)
16186            }
16187        }
16188        struct GeneratedVisitor;
16189        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16190            type Value = TriggerManualCompactionRequest;
16191
16192            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16193                formatter.write_str("struct hummock.TriggerManualCompactionRequest")
16194            }
16195
16196            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerManualCompactionRequest, V::Error>
16197                where
16198                    V: serde::de::MapAccess<'de>,
16199            {
16200                let mut compaction_group_id__ = None;
16201                let mut key_range__ = None;
16202                let mut table_id__ = None;
16203                let mut level__ = None;
16204                let mut sst_ids__ = None;
16205                while let Some(k) = map_.next_key()? {
16206                    match k {
16207                        GeneratedField::CompactionGroupId => {
16208                            if compaction_group_id__.is_some() {
16209                                return Err(serde::de::Error::duplicate_field("compactionGroupId"));
16210                            }
16211                            compaction_group_id__ = 
16212                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16213                            ;
16214                        }
16215                        GeneratedField::KeyRange => {
16216                            if key_range__.is_some() {
16217                                return Err(serde::de::Error::duplicate_field("keyRange"));
16218                            }
16219                            key_range__ = map_.next_value()?;
16220                        }
16221                        GeneratedField::TableId => {
16222                            if table_id__.is_some() {
16223                                return Err(serde::de::Error::duplicate_field("tableId"));
16224                            }
16225                            table_id__ = 
16226                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16227                            ;
16228                        }
16229                        GeneratedField::Level => {
16230                            if level__.is_some() {
16231                                return Err(serde::de::Error::duplicate_field("level"));
16232                            }
16233                            level__ = 
16234                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16235                            ;
16236                        }
16237                        GeneratedField::SstIds => {
16238                            if sst_ids__.is_some() {
16239                                return Err(serde::de::Error::duplicate_field("sstIds"));
16240                            }
16241                            sst_ids__ = 
16242                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16243                                    .into_iter().map(|x| x.0).collect())
16244                            ;
16245                        }
16246                    }
16247                }
16248                Ok(TriggerManualCompactionRequest {
16249                    compaction_group_id: compaction_group_id__.unwrap_or_default(),
16250                    key_range: key_range__,
16251                    table_id: table_id__.unwrap_or_default(),
16252                    level: level__.unwrap_or_default(),
16253                    sst_ids: sst_ids__.unwrap_or_default(),
16254                })
16255            }
16256        }
16257        deserializer.deserialize_struct("hummock.TriggerManualCompactionRequest", FIELDS, GeneratedVisitor)
16258    }
16259}
16260impl serde::Serialize for TriggerManualCompactionResponse {
16261    #[allow(deprecated)]
16262    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16263    where
16264        S: serde::Serializer,
16265    {
16266        use serde::ser::SerializeStruct;
16267        let mut len = 0;
16268        if self.status.is_some() {
16269            len += 1;
16270        }
16271        let mut struct_ser = serializer.serialize_struct("hummock.TriggerManualCompactionResponse", len)?;
16272        if let Some(v) = self.status.as_ref() {
16273            struct_ser.serialize_field("status", v)?;
16274        }
16275        struct_ser.end()
16276    }
16277}
16278impl<'de> serde::Deserialize<'de> for TriggerManualCompactionResponse {
16279    #[allow(deprecated)]
16280    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16281    where
16282        D: serde::Deserializer<'de>,
16283    {
16284        const FIELDS: &[&str] = &[
16285            "status",
16286        ];
16287
16288        #[allow(clippy::enum_variant_names)]
16289        enum GeneratedField {
16290            Status,
16291        }
16292        impl<'de> serde::Deserialize<'de> for GeneratedField {
16293            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16294            where
16295                D: serde::Deserializer<'de>,
16296            {
16297                struct GeneratedVisitor;
16298
16299                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16300                    type Value = GeneratedField;
16301
16302                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16303                        write!(formatter, "expected one of: {:?}", &FIELDS)
16304                    }
16305
16306                    #[allow(unused_variables)]
16307                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16308                    where
16309                        E: serde::de::Error,
16310                    {
16311                        match value {
16312                            "status" => Ok(GeneratedField::Status),
16313                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16314                        }
16315                    }
16316                }
16317                deserializer.deserialize_identifier(GeneratedVisitor)
16318            }
16319        }
16320        struct GeneratedVisitor;
16321        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16322            type Value = TriggerManualCompactionResponse;
16323
16324            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16325                formatter.write_str("struct hummock.TriggerManualCompactionResponse")
16326            }
16327
16328            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerManualCompactionResponse, V::Error>
16329                where
16330                    V: serde::de::MapAccess<'de>,
16331            {
16332                let mut status__ = None;
16333                while let Some(k) = map_.next_key()? {
16334                    match k {
16335                        GeneratedField::Status => {
16336                            if status__.is_some() {
16337                                return Err(serde::de::Error::duplicate_field("status"));
16338                            }
16339                            status__ = map_.next_value()?;
16340                        }
16341                    }
16342                }
16343                Ok(TriggerManualCompactionResponse {
16344                    status: status__,
16345                })
16346            }
16347        }
16348        deserializer.deserialize_struct("hummock.TriggerManualCompactionResponse", FIELDS, GeneratedVisitor)
16349    }
16350}
16351impl serde::Serialize for TruncateTables {
16352    #[allow(deprecated)]
16353    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16354    where
16355        S: serde::Serializer,
16356    {
16357        use serde::ser::SerializeStruct;
16358        let mut len = 0;
16359        if !self.table_ids.is_empty() {
16360            len += 1;
16361        }
16362        let mut struct_ser = serializer.serialize_struct("hummock.TruncateTables", len)?;
16363        if !self.table_ids.is_empty() {
16364            struct_ser.serialize_field("tableIds", &self.table_ids)?;
16365        }
16366        struct_ser.end()
16367    }
16368}
16369impl<'de> serde::Deserialize<'de> for TruncateTables {
16370    #[allow(deprecated)]
16371    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16372    where
16373        D: serde::Deserializer<'de>,
16374    {
16375        const FIELDS: &[&str] = &[
16376            "table_ids",
16377            "tableIds",
16378        ];
16379
16380        #[allow(clippy::enum_variant_names)]
16381        enum GeneratedField {
16382            TableIds,
16383        }
16384        impl<'de> serde::Deserialize<'de> for GeneratedField {
16385            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16386            where
16387                D: serde::Deserializer<'de>,
16388            {
16389                struct GeneratedVisitor;
16390
16391                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16392                    type Value = GeneratedField;
16393
16394                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16395                        write!(formatter, "expected one of: {:?}", &FIELDS)
16396                    }
16397
16398                    #[allow(unused_variables)]
16399                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16400                    where
16401                        E: serde::de::Error,
16402                    {
16403                        match value {
16404                            "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
16405                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16406                        }
16407                    }
16408                }
16409                deserializer.deserialize_identifier(GeneratedVisitor)
16410            }
16411        }
16412        struct GeneratedVisitor;
16413        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16414            type Value = TruncateTables;
16415
16416            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16417                formatter.write_str("struct hummock.TruncateTables")
16418            }
16419
16420            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TruncateTables, V::Error>
16421                where
16422                    V: serde::de::MapAccess<'de>,
16423            {
16424                let mut table_ids__ = None;
16425                while let Some(k) = map_.next_key()? {
16426                    match k {
16427                        GeneratedField::TableIds => {
16428                            if table_ids__.is_some() {
16429                                return Err(serde::de::Error::duplicate_field("tableIds"));
16430                            }
16431                            table_ids__ = 
16432                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16433                                    .into_iter().map(|x| x.0).collect())
16434                            ;
16435                        }
16436                    }
16437                }
16438                Ok(TruncateTables {
16439                    table_ids: table_ids__.unwrap_or_default(),
16440                })
16441            }
16442        }
16443        deserializer.deserialize_struct("hummock.TruncateTables", FIELDS, GeneratedVisitor)
16444    }
16445}
16446impl serde::Serialize for UnpinVersionBeforeRequest {
16447    #[allow(deprecated)]
16448    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16449    where
16450        S: serde::Serializer,
16451    {
16452        use serde::ser::SerializeStruct;
16453        let mut len = 0;
16454        if self.context_id != 0 {
16455            len += 1;
16456        }
16457        if self.unpin_version_before != 0 {
16458            len += 1;
16459        }
16460        let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionBeforeRequest", len)?;
16461        if self.context_id != 0 {
16462            struct_ser.serialize_field("contextId", &self.context_id)?;
16463        }
16464        if self.unpin_version_before != 0 {
16465            #[allow(clippy::needless_borrow)]
16466            #[allow(clippy::needless_borrows_for_generic_args)]
16467            struct_ser.serialize_field("unpinVersionBefore", ToString::to_string(&self.unpin_version_before).as_str())?;
16468        }
16469        struct_ser.end()
16470    }
16471}
16472impl<'de> serde::Deserialize<'de> for UnpinVersionBeforeRequest {
16473    #[allow(deprecated)]
16474    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16475    where
16476        D: serde::Deserializer<'de>,
16477    {
16478        const FIELDS: &[&str] = &[
16479            "context_id",
16480            "contextId",
16481            "unpin_version_before",
16482            "unpinVersionBefore",
16483        ];
16484
16485        #[allow(clippy::enum_variant_names)]
16486        enum GeneratedField {
16487            ContextId,
16488            UnpinVersionBefore,
16489        }
16490        impl<'de> serde::Deserialize<'de> for GeneratedField {
16491            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16492            where
16493                D: serde::Deserializer<'de>,
16494            {
16495                struct GeneratedVisitor;
16496
16497                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16498                    type Value = GeneratedField;
16499
16500                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16501                        write!(formatter, "expected one of: {:?}", &FIELDS)
16502                    }
16503
16504                    #[allow(unused_variables)]
16505                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16506                    where
16507                        E: serde::de::Error,
16508                    {
16509                        match value {
16510                            "contextId" | "context_id" => Ok(GeneratedField::ContextId),
16511                            "unpinVersionBefore" | "unpin_version_before" => Ok(GeneratedField::UnpinVersionBefore),
16512                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16513                        }
16514                    }
16515                }
16516                deserializer.deserialize_identifier(GeneratedVisitor)
16517            }
16518        }
16519        struct GeneratedVisitor;
16520        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16521            type Value = UnpinVersionBeforeRequest;
16522
16523            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16524                formatter.write_str("struct hummock.UnpinVersionBeforeRequest")
16525            }
16526
16527            fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionBeforeRequest, V::Error>
16528                where
16529                    V: serde::de::MapAccess<'de>,
16530            {
16531                let mut context_id__ = None;
16532                let mut unpin_version_before__ = None;
16533                while let Some(k) = map_.next_key()? {
16534                    match k {
16535                        GeneratedField::ContextId => {
16536                            if context_id__.is_some() {
16537                                return Err(serde::de::Error::duplicate_field("contextId"));
16538                            }
16539                            context_id__ = 
16540                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16541                            ;
16542                        }
16543                        GeneratedField::UnpinVersionBefore => {
16544                            if unpin_version_before__.is_some() {
16545                                return Err(serde::de::Error::duplicate_field("unpinVersionBefore"));
16546                            }
16547                            unpin_version_before__ = 
16548                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16549                            ;
16550                        }
16551                    }
16552                }
16553                Ok(UnpinVersionBeforeRequest {
16554                    context_id: context_id__.unwrap_or_default(),
16555                    unpin_version_before: unpin_version_before__.unwrap_or_default(),
16556                })
16557            }
16558        }
16559        deserializer.deserialize_struct("hummock.UnpinVersionBeforeRequest", FIELDS, GeneratedVisitor)
16560    }
16561}
16562impl serde::Serialize for UnpinVersionBeforeResponse {
16563    #[allow(deprecated)]
16564    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16565    where
16566        S: serde::Serializer,
16567    {
16568        use serde::ser::SerializeStruct;
16569        let mut len = 0;
16570        if self.status.is_some() {
16571            len += 1;
16572        }
16573        let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionBeforeResponse", len)?;
16574        if let Some(v) = self.status.as_ref() {
16575            struct_ser.serialize_field("status", v)?;
16576        }
16577        struct_ser.end()
16578    }
16579}
16580impl<'de> serde::Deserialize<'de> for UnpinVersionBeforeResponse {
16581    #[allow(deprecated)]
16582    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16583    where
16584        D: serde::Deserializer<'de>,
16585    {
16586        const FIELDS: &[&str] = &[
16587            "status",
16588        ];
16589
16590        #[allow(clippy::enum_variant_names)]
16591        enum GeneratedField {
16592            Status,
16593        }
16594        impl<'de> serde::Deserialize<'de> for GeneratedField {
16595            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16596            where
16597                D: serde::Deserializer<'de>,
16598            {
16599                struct GeneratedVisitor;
16600
16601                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16602                    type Value = GeneratedField;
16603
16604                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16605                        write!(formatter, "expected one of: {:?}", &FIELDS)
16606                    }
16607
16608                    #[allow(unused_variables)]
16609                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16610                    where
16611                        E: serde::de::Error,
16612                    {
16613                        match value {
16614                            "status" => Ok(GeneratedField::Status),
16615                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16616                        }
16617                    }
16618                }
16619                deserializer.deserialize_identifier(GeneratedVisitor)
16620            }
16621        }
16622        struct GeneratedVisitor;
16623        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16624            type Value = UnpinVersionBeforeResponse;
16625
16626            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16627                formatter.write_str("struct hummock.UnpinVersionBeforeResponse")
16628            }
16629
16630            fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionBeforeResponse, V::Error>
16631                where
16632                    V: serde::de::MapAccess<'de>,
16633            {
16634                let mut status__ = None;
16635                while let Some(k) = map_.next_key()? {
16636                    match k {
16637                        GeneratedField::Status => {
16638                            if status__.is_some() {
16639                                return Err(serde::de::Error::duplicate_field("status"));
16640                            }
16641                            status__ = map_.next_value()?;
16642                        }
16643                    }
16644                }
16645                Ok(UnpinVersionBeforeResponse {
16646                    status: status__,
16647                })
16648            }
16649        }
16650        deserializer.deserialize_struct("hummock.UnpinVersionBeforeResponse", FIELDS, GeneratedVisitor)
16651    }
16652}
16653impl serde::Serialize for UnpinVersionRequest {
16654    #[allow(deprecated)]
16655    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16656    where
16657        S: serde::Serializer,
16658    {
16659        use serde::ser::SerializeStruct;
16660        let mut len = 0;
16661        if self.context_id != 0 {
16662            len += 1;
16663        }
16664        let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionRequest", len)?;
16665        if self.context_id != 0 {
16666            struct_ser.serialize_field("contextId", &self.context_id)?;
16667        }
16668        struct_ser.end()
16669    }
16670}
16671impl<'de> serde::Deserialize<'de> for UnpinVersionRequest {
16672    #[allow(deprecated)]
16673    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16674    where
16675        D: serde::Deserializer<'de>,
16676    {
16677        const FIELDS: &[&str] = &[
16678            "context_id",
16679            "contextId",
16680        ];
16681
16682        #[allow(clippy::enum_variant_names)]
16683        enum GeneratedField {
16684            ContextId,
16685        }
16686        impl<'de> serde::Deserialize<'de> for GeneratedField {
16687            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16688            where
16689                D: serde::Deserializer<'de>,
16690            {
16691                struct GeneratedVisitor;
16692
16693                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16694                    type Value = GeneratedField;
16695
16696                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16697                        write!(formatter, "expected one of: {:?}", &FIELDS)
16698                    }
16699
16700                    #[allow(unused_variables)]
16701                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16702                    where
16703                        E: serde::de::Error,
16704                    {
16705                        match value {
16706                            "contextId" | "context_id" => Ok(GeneratedField::ContextId),
16707                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16708                        }
16709                    }
16710                }
16711                deserializer.deserialize_identifier(GeneratedVisitor)
16712            }
16713        }
16714        struct GeneratedVisitor;
16715        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16716            type Value = UnpinVersionRequest;
16717
16718            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16719                formatter.write_str("struct hummock.UnpinVersionRequest")
16720            }
16721
16722            fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionRequest, V::Error>
16723                where
16724                    V: serde::de::MapAccess<'de>,
16725            {
16726                let mut context_id__ = None;
16727                while let Some(k) = map_.next_key()? {
16728                    match k {
16729                        GeneratedField::ContextId => {
16730                            if context_id__.is_some() {
16731                                return Err(serde::de::Error::duplicate_field("contextId"));
16732                            }
16733                            context_id__ = 
16734                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16735                            ;
16736                        }
16737                    }
16738                }
16739                Ok(UnpinVersionRequest {
16740                    context_id: context_id__.unwrap_or_default(),
16741                })
16742            }
16743        }
16744        deserializer.deserialize_struct("hummock.UnpinVersionRequest", FIELDS, GeneratedVisitor)
16745    }
16746}
16747impl serde::Serialize for UnpinVersionResponse {
16748    #[allow(deprecated)]
16749    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16750    where
16751        S: serde::Serializer,
16752    {
16753        use serde::ser::SerializeStruct;
16754        let mut len = 0;
16755        if self.status.is_some() {
16756            len += 1;
16757        }
16758        let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionResponse", len)?;
16759        if let Some(v) = self.status.as_ref() {
16760            struct_ser.serialize_field("status", v)?;
16761        }
16762        struct_ser.end()
16763    }
16764}
16765impl<'de> serde::Deserialize<'de> for UnpinVersionResponse {
16766    #[allow(deprecated)]
16767    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16768    where
16769        D: serde::Deserializer<'de>,
16770    {
16771        const FIELDS: &[&str] = &[
16772            "status",
16773        ];
16774
16775        #[allow(clippy::enum_variant_names)]
16776        enum GeneratedField {
16777            Status,
16778        }
16779        impl<'de> serde::Deserialize<'de> for GeneratedField {
16780            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16781            where
16782                D: serde::Deserializer<'de>,
16783            {
16784                struct GeneratedVisitor;
16785
16786                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16787                    type Value = GeneratedField;
16788
16789                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16790                        write!(formatter, "expected one of: {:?}", &FIELDS)
16791                    }
16792
16793                    #[allow(unused_variables)]
16794                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16795                    where
16796                        E: serde::de::Error,
16797                    {
16798                        match value {
16799                            "status" => Ok(GeneratedField::Status),
16800                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16801                        }
16802                    }
16803                }
16804                deserializer.deserialize_identifier(GeneratedVisitor)
16805            }
16806        }
16807        struct GeneratedVisitor;
16808        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16809            type Value = UnpinVersionResponse;
16810
16811            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16812                formatter.write_str("struct hummock.UnpinVersionResponse")
16813            }
16814
16815            fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionResponse, V::Error>
16816                where
16817                    V: serde::de::MapAccess<'de>,
16818            {
16819                let mut status__ = None;
16820                while let Some(k) = map_.next_key()? {
16821                    match k {
16822                        GeneratedField::Status => {
16823                            if status__.is_some() {
16824                                return Err(serde::de::Error::duplicate_field("status"));
16825                            }
16826                            status__ = map_.next_value()?;
16827                        }
16828                    }
16829                }
16830                Ok(UnpinVersionResponse {
16831                    status: status__,
16832                })
16833            }
16834        }
16835        deserializer.deserialize_struct("hummock.UnpinVersionResponse", FIELDS, GeneratedVisitor)
16836    }
16837}
16838impl serde::Serialize for VacuumTask {
16839    #[allow(deprecated)]
16840    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16841    where
16842        S: serde::Serializer,
16843    {
16844        use serde::ser::SerializeStruct;
16845        let mut len = 0;
16846        if !self.sstable_object_ids.is_empty() {
16847            len += 1;
16848        }
16849        let mut struct_ser = serializer.serialize_struct("hummock.VacuumTask", len)?;
16850        if !self.sstable_object_ids.is_empty() {
16851            struct_ser.serialize_field("sstableObjectIds", &self.sstable_object_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
16852        }
16853        struct_ser.end()
16854    }
16855}
16856impl<'de> serde::Deserialize<'de> for VacuumTask {
16857    #[allow(deprecated)]
16858    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16859    where
16860        D: serde::Deserializer<'de>,
16861    {
16862        const FIELDS: &[&str] = &[
16863            "sstable_object_ids",
16864            "sstableObjectIds",
16865        ];
16866
16867        #[allow(clippy::enum_variant_names)]
16868        enum GeneratedField {
16869            SstableObjectIds,
16870        }
16871        impl<'de> serde::Deserialize<'de> for GeneratedField {
16872            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16873            where
16874                D: serde::Deserializer<'de>,
16875            {
16876                struct GeneratedVisitor;
16877
16878                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16879                    type Value = GeneratedField;
16880
16881                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16882                        write!(formatter, "expected one of: {:?}", &FIELDS)
16883                    }
16884
16885                    #[allow(unused_variables)]
16886                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16887                    where
16888                        E: serde::de::Error,
16889                    {
16890                        match value {
16891                            "sstableObjectIds" | "sstable_object_ids" => Ok(GeneratedField::SstableObjectIds),
16892                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16893                        }
16894                    }
16895                }
16896                deserializer.deserialize_identifier(GeneratedVisitor)
16897            }
16898        }
16899        struct GeneratedVisitor;
16900        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16901            type Value = VacuumTask;
16902
16903            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16904                formatter.write_str("struct hummock.VacuumTask")
16905            }
16906
16907            fn visit_map<V>(self, mut map_: V) -> std::result::Result<VacuumTask, V::Error>
16908                where
16909                    V: serde::de::MapAccess<'de>,
16910            {
16911                let mut sstable_object_ids__ = None;
16912                while let Some(k) = map_.next_key()? {
16913                    match k {
16914                        GeneratedField::SstableObjectIds => {
16915                            if sstable_object_ids__.is_some() {
16916                                return Err(serde::de::Error::duplicate_field("sstableObjectIds"));
16917                            }
16918                            sstable_object_ids__ = 
16919                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16920                                    .into_iter().map(|x| x.0).collect())
16921                            ;
16922                        }
16923                    }
16924                }
16925                Ok(VacuumTask {
16926                    sstable_object_ids: sstable_object_ids__.unwrap_or_default(),
16927                })
16928            }
16929        }
16930        deserializer.deserialize_struct("hummock.VacuumTask", FIELDS, GeneratedVisitor)
16931    }
16932}
16933impl serde::Serialize for ValidationTask {
16934    #[allow(deprecated)]
16935    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16936    where
16937        S: serde::Serializer,
16938    {
16939        use serde::ser::SerializeStruct;
16940        let mut len = 0;
16941        if !self.sst_infos.is_empty() {
16942            len += 1;
16943        }
16944        if !self.sst_id_to_worker_id.is_empty() {
16945            len += 1;
16946        }
16947        let mut struct_ser = serializer.serialize_struct("hummock.ValidationTask", len)?;
16948        if !self.sst_infos.is_empty() {
16949            struct_ser.serialize_field("sstInfos", &self.sst_infos)?;
16950        }
16951        if !self.sst_id_to_worker_id.is_empty() {
16952            struct_ser.serialize_field("sstIdToWorkerId", &self.sst_id_to_worker_id)?;
16953        }
16954        struct_ser.end()
16955    }
16956}
16957impl<'de> serde::Deserialize<'de> for ValidationTask {
16958    #[allow(deprecated)]
16959    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16960    where
16961        D: serde::Deserializer<'de>,
16962    {
16963        const FIELDS: &[&str] = &[
16964            "sst_infos",
16965            "sstInfos",
16966            "sst_id_to_worker_id",
16967            "sstIdToWorkerId",
16968        ];
16969
16970        #[allow(clippy::enum_variant_names)]
16971        enum GeneratedField {
16972            SstInfos,
16973            SstIdToWorkerId,
16974        }
16975        impl<'de> serde::Deserialize<'de> for GeneratedField {
16976            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16977            where
16978                D: serde::Deserializer<'de>,
16979            {
16980                struct GeneratedVisitor;
16981
16982                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16983                    type Value = GeneratedField;
16984
16985                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16986                        write!(formatter, "expected one of: {:?}", &FIELDS)
16987                    }
16988
16989                    #[allow(unused_variables)]
16990                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16991                    where
16992                        E: serde::de::Error,
16993                    {
16994                        match value {
16995                            "sstInfos" | "sst_infos" => Ok(GeneratedField::SstInfos),
16996                            "sstIdToWorkerId" | "sst_id_to_worker_id" => Ok(GeneratedField::SstIdToWorkerId),
16997                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16998                        }
16999                    }
17000                }
17001                deserializer.deserialize_identifier(GeneratedVisitor)
17002            }
17003        }
17004        struct GeneratedVisitor;
17005        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17006            type Value = ValidationTask;
17007
17008            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17009                formatter.write_str("struct hummock.ValidationTask")
17010            }
17011
17012            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValidationTask, V::Error>
17013                where
17014                    V: serde::de::MapAccess<'de>,
17015            {
17016                let mut sst_infos__ = None;
17017                let mut sst_id_to_worker_id__ = None;
17018                while let Some(k) = map_.next_key()? {
17019                    match k {
17020                        GeneratedField::SstInfos => {
17021                            if sst_infos__.is_some() {
17022                                return Err(serde::de::Error::duplicate_field("sstInfos"));
17023                            }
17024                            sst_infos__ = Some(map_.next_value()?);
17025                        }
17026                        GeneratedField::SstIdToWorkerId => {
17027                            if sst_id_to_worker_id__.is_some() {
17028                                return Err(serde::de::Error::duplicate_field("sstIdToWorkerId"));
17029                            }
17030                            sst_id_to_worker_id__ = Some(
17031                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u32>>>()?
17032                                    .into_iter().map(|(k,v)| (k.0, v.0)).collect()
17033                            );
17034                        }
17035                    }
17036                }
17037                Ok(ValidationTask {
17038                    sst_infos: sst_infos__.unwrap_or_default(),
17039                    sst_id_to_worker_id: sst_id_to_worker_id__.unwrap_or_default(),
17040                })
17041            }
17042        }
17043        deserializer.deserialize_struct("hummock.ValidationTask", FIELDS, GeneratedVisitor)
17044    }
17045}
17046impl serde::Serialize for VectorFileInfo {
17047    #[allow(deprecated)]
17048    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17049    where
17050        S: serde::Serializer,
17051    {
17052        use serde::ser::SerializeStruct;
17053        let mut len = 0;
17054        if self.object_id != 0 {
17055            len += 1;
17056        }
17057        if self.file_size != 0 {
17058            len += 1;
17059        }
17060        if self.start_vector_id != 0 {
17061            len += 1;
17062        }
17063        if self.vector_count != 0 {
17064            len += 1;
17065        }
17066        if self.meta_offset != 0 {
17067            len += 1;
17068        }
17069        let mut struct_ser = serializer.serialize_struct("hummock.VectorFileInfo", len)?;
17070        if self.object_id != 0 {
17071            #[allow(clippy::needless_borrow)]
17072            #[allow(clippy::needless_borrows_for_generic_args)]
17073            struct_ser.serialize_field("objectId", ToString::to_string(&self.object_id).as_str())?;
17074        }
17075        if self.file_size != 0 {
17076            #[allow(clippy::needless_borrow)]
17077            #[allow(clippy::needless_borrows_for_generic_args)]
17078            struct_ser.serialize_field("fileSize", ToString::to_string(&self.file_size).as_str())?;
17079        }
17080        if self.start_vector_id != 0 {
17081            #[allow(clippy::needless_borrow)]
17082            #[allow(clippy::needless_borrows_for_generic_args)]
17083            struct_ser.serialize_field("startVectorId", ToString::to_string(&self.start_vector_id).as_str())?;
17084        }
17085        if self.vector_count != 0 {
17086            struct_ser.serialize_field("vectorCount", &self.vector_count)?;
17087        }
17088        if self.meta_offset != 0 {
17089            #[allow(clippy::needless_borrow)]
17090            #[allow(clippy::needless_borrows_for_generic_args)]
17091            struct_ser.serialize_field("metaOffset", ToString::to_string(&self.meta_offset).as_str())?;
17092        }
17093        struct_ser.end()
17094    }
17095}
17096impl<'de> serde::Deserialize<'de> for VectorFileInfo {
17097    #[allow(deprecated)]
17098    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17099    where
17100        D: serde::Deserializer<'de>,
17101    {
17102        const FIELDS: &[&str] = &[
17103            "object_id",
17104            "objectId",
17105            "file_size",
17106            "fileSize",
17107            "start_vector_id",
17108            "startVectorId",
17109            "vector_count",
17110            "vectorCount",
17111            "meta_offset",
17112            "metaOffset",
17113        ];
17114
17115        #[allow(clippy::enum_variant_names)]
17116        enum GeneratedField {
17117            ObjectId,
17118            FileSize,
17119            StartVectorId,
17120            VectorCount,
17121            MetaOffset,
17122        }
17123        impl<'de> serde::Deserialize<'de> for GeneratedField {
17124            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17125            where
17126                D: serde::Deserializer<'de>,
17127            {
17128                struct GeneratedVisitor;
17129
17130                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17131                    type Value = GeneratedField;
17132
17133                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17134                        write!(formatter, "expected one of: {:?}", &FIELDS)
17135                    }
17136
17137                    #[allow(unused_variables)]
17138                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17139                    where
17140                        E: serde::de::Error,
17141                    {
17142                        match value {
17143                            "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
17144                            "fileSize" | "file_size" => Ok(GeneratedField::FileSize),
17145                            "startVectorId" | "start_vector_id" => Ok(GeneratedField::StartVectorId),
17146                            "vectorCount" | "vector_count" => Ok(GeneratedField::VectorCount),
17147                            "metaOffset" | "meta_offset" => Ok(GeneratedField::MetaOffset),
17148                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17149                        }
17150                    }
17151                }
17152                deserializer.deserialize_identifier(GeneratedVisitor)
17153            }
17154        }
17155        struct GeneratedVisitor;
17156        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17157            type Value = VectorFileInfo;
17158
17159            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17160                formatter.write_str("struct hummock.VectorFileInfo")
17161            }
17162
17163            fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorFileInfo, V::Error>
17164                where
17165                    V: serde::de::MapAccess<'de>,
17166            {
17167                let mut object_id__ = None;
17168                let mut file_size__ = None;
17169                let mut start_vector_id__ = None;
17170                let mut vector_count__ = None;
17171                let mut meta_offset__ = None;
17172                while let Some(k) = map_.next_key()? {
17173                    match k {
17174                        GeneratedField::ObjectId => {
17175                            if object_id__.is_some() {
17176                                return Err(serde::de::Error::duplicate_field("objectId"));
17177                            }
17178                            object_id__ = 
17179                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17180                            ;
17181                        }
17182                        GeneratedField::FileSize => {
17183                            if file_size__.is_some() {
17184                                return Err(serde::de::Error::duplicate_field("fileSize"));
17185                            }
17186                            file_size__ = 
17187                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17188                            ;
17189                        }
17190                        GeneratedField::StartVectorId => {
17191                            if start_vector_id__.is_some() {
17192                                return Err(serde::de::Error::duplicate_field("startVectorId"));
17193                            }
17194                            start_vector_id__ = 
17195                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17196                            ;
17197                        }
17198                        GeneratedField::VectorCount => {
17199                            if vector_count__.is_some() {
17200                                return Err(serde::de::Error::duplicate_field("vectorCount"));
17201                            }
17202                            vector_count__ = 
17203                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17204                            ;
17205                        }
17206                        GeneratedField::MetaOffset => {
17207                            if meta_offset__.is_some() {
17208                                return Err(serde::de::Error::duplicate_field("metaOffset"));
17209                            }
17210                            meta_offset__ = 
17211                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17212                            ;
17213                        }
17214                    }
17215                }
17216                Ok(VectorFileInfo {
17217                    object_id: object_id__.unwrap_or_default(),
17218                    file_size: file_size__.unwrap_or_default(),
17219                    start_vector_id: start_vector_id__.unwrap_or_default(),
17220                    vector_count: vector_count__.unwrap_or_default(),
17221                    meta_offset: meta_offset__.unwrap_or_default(),
17222                })
17223            }
17224        }
17225        deserializer.deserialize_struct("hummock.VectorFileInfo", FIELDS, GeneratedVisitor)
17226    }
17227}
17228impl serde::Serialize for VectorIndex {
17229    #[allow(deprecated)]
17230    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17231    where
17232        S: serde::Serializer,
17233    {
17234        use serde::ser::SerializeStruct;
17235        let mut len = 0;
17236        if self.dimension != 0 {
17237            len += 1;
17238        }
17239        if self.distance_type != 0 {
17240            len += 1;
17241        }
17242        if self.variant.is_some() {
17243            len += 1;
17244        }
17245        let mut struct_ser = serializer.serialize_struct("hummock.VectorIndex", len)?;
17246        if self.dimension != 0 {
17247            struct_ser.serialize_field("dimension", &self.dimension)?;
17248        }
17249        if self.distance_type != 0 {
17250            let v = super::common::DistanceType::try_from(self.distance_type)
17251                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distance_type)))?;
17252            struct_ser.serialize_field("distanceType", &v)?;
17253        }
17254        if let Some(v) = self.variant.as_ref() {
17255            match v {
17256                vector_index::Variant::Flat(v) => {
17257                    struct_ser.serialize_field("flat", v)?;
17258                }
17259                vector_index::Variant::HnswFlat(v) => {
17260                    struct_ser.serialize_field("hnswFlat", v)?;
17261                }
17262            }
17263        }
17264        struct_ser.end()
17265    }
17266}
17267impl<'de> serde::Deserialize<'de> for VectorIndex {
17268    #[allow(deprecated)]
17269    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17270    where
17271        D: serde::Deserializer<'de>,
17272    {
17273        const FIELDS: &[&str] = &[
17274            "dimension",
17275            "distance_type",
17276            "distanceType",
17277            "flat",
17278            "hnsw_flat",
17279            "hnswFlat",
17280        ];
17281
17282        #[allow(clippy::enum_variant_names)]
17283        enum GeneratedField {
17284            Dimension,
17285            DistanceType,
17286            Flat,
17287            HnswFlat,
17288        }
17289        impl<'de> serde::Deserialize<'de> for GeneratedField {
17290            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17291            where
17292                D: serde::Deserializer<'de>,
17293            {
17294                struct GeneratedVisitor;
17295
17296                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17297                    type Value = GeneratedField;
17298
17299                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17300                        write!(formatter, "expected one of: {:?}", &FIELDS)
17301                    }
17302
17303                    #[allow(unused_variables)]
17304                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17305                    where
17306                        E: serde::de::Error,
17307                    {
17308                        match value {
17309                            "dimension" => Ok(GeneratedField::Dimension),
17310                            "distanceType" | "distance_type" => Ok(GeneratedField::DistanceType),
17311                            "flat" => Ok(GeneratedField::Flat),
17312                            "hnswFlat" | "hnsw_flat" => Ok(GeneratedField::HnswFlat),
17313                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17314                        }
17315                    }
17316                }
17317                deserializer.deserialize_identifier(GeneratedVisitor)
17318            }
17319        }
17320        struct GeneratedVisitor;
17321        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17322            type Value = VectorIndex;
17323
17324            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17325                formatter.write_str("struct hummock.VectorIndex")
17326            }
17327
17328            fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndex, V::Error>
17329                where
17330                    V: serde::de::MapAccess<'de>,
17331            {
17332                let mut dimension__ = None;
17333                let mut distance_type__ = None;
17334                let mut variant__ = None;
17335                while let Some(k) = map_.next_key()? {
17336                    match k {
17337                        GeneratedField::Dimension => {
17338                            if dimension__.is_some() {
17339                                return Err(serde::de::Error::duplicate_field("dimension"));
17340                            }
17341                            dimension__ = 
17342                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17343                            ;
17344                        }
17345                        GeneratedField::DistanceType => {
17346                            if distance_type__.is_some() {
17347                                return Err(serde::de::Error::duplicate_field("distanceType"));
17348                            }
17349                            distance_type__ = Some(map_.next_value::<super::common::DistanceType>()? as i32);
17350                        }
17351                        GeneratedField::Flat => {
17352                            if variant__.is_some() {
17353                                return Err(serde::de::Error::duplicate_field("flat"));
17354                            }
17355                            variant__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index::Variant::Flat)
17356;
17357                        }
17358                        GeneratedField::HnswFlat => {
17359                            if variant__.is_some() {
17360                                return Err(serde::de::Error::duplicate_field("hnswFlat"));
17361                            }
17362                            variant__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index::Variant::HnswFlat)
17363;
17364                        }
17365                    }
17366                }
17367                Ok(VectorIndex {
17368                    dimension: dimension__.unwrap_or_default(),
17369                    distance_type: distance_type__.unwrap_or_default(),
17370                    variant: variant__,
17371                })
17372            }
17373        }
17374        deserializer.deserialize_struct("hummock.VectorIndex", FIELDS, GeneratedVisitor)
17375    }
17376}
17377impl serde::Serialize for VectorIndexDelta {
17378    #[allow(deprecated)]
17379    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17380    where
17381        S: serde::Serializer,
17382    {
17383        use serde::ser::SerializeStruct;
17384        let mut len = 0;
17385        if self.delta.is_some() {
17386            len += 1;
17387        }
17388        let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta", len)?;
17389        if let Some(v) = self.delta.as_ref() {
17390            match v {
17391                vector_index_delta::Delta::Init(v) => {
17392                    struct_ser.serialize_field("init", v)?;
17393                }
17394                vector_index_delta::Delta::Adds(v) => {
17395                    struct_ser.serialize_field("adds", v)?;
17396                }
17397            }
17398        }
17399        struct_ser.end()
17400    }
17401}
17402impl<'de> serde::Deserialize<'de> for VectorIndexDelta {
17403    #[allow(deprecated)]
17404    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17405    where
17406        D: serde::Deserializer<'de>,
17407    {
17408        const FIELDS: &[&str] = &[
17409            "init",
17410            "adds",
17411        ];
17412
17413        #[allow(clippy::enum_variant_names)]
17414        enum GeneratedField {
17415            Init,
17416            Adds,
17417        }
17418        impl<'de> serde::Deserialize<'de> for GeneratedField {
17419            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17420            where
17421                D: serde::Deserializer<'de>,
17422            {
17423                struct GeneratedVisitor;
17424
17425                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17426                    type Value = GeneratedField;
17427
17428                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17429                        write!(formatter, "expected one of: {:?}", &FIELDS)
17430                    }
17431
17432                    #[allow(unused_variables)]
17433                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17434                    where
17435                        E: serde::de::Error,
17436                    {
17437                        match value {
17438                            "init" => Ok(GeneratedField::Init),
17439                            "adds" => Ok(GeneratedField::Adds),
17440                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17441                        }
17442                    }
17443                }
17444                deserializer.deserialize_identifier(GeneratedVisitor)
17445            }
17446        }
17447        struct GeneratedVisitor;
17448        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17449            type Value = VectorIndexDelta;
17450
17451            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17452                formatter.write_str("struct hummock.VectorIndexDelta")
17453            }
17454
17455            fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexDelta, V::Error>
17456                where
17457                    V: serde::de::MapAccess<'de>,
17458            {
17459                let mut delta__ = None;
17460                while let Some(k) = map_.next_key()? {
17461                    match k {
17462                        GeneratedField::Init => {
17463                            if delta__.is_some() {
17464                                return Err(serde::de::Error::duplicate_field("init"));
17465                            }
17466                            delta__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_delta::Delta::Init)
17467;
17468                        }
17469                        GeneratedField::Adds => {
17470                            if delta__.is_some() {
17471                                return Err(serde::de::Error::duplicate_field("adds"));
17472                            }
17473                            delta__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_delta::Delta::Adds)
17474;
17475                        }
17476                    }
17477                }
17478                Ok(VectorIndexDelta {
17479                    delta: delta__,
17480                })
17481            }
17482        }
17483        deserializer.deserialize_struct("hummock.VectorIndexDelta", FIELDS, GeneratedVisitor)
17484    }
17485}
17486impl serde::Serialize for vector_index_delta::VectorIndexAdd {
17487    #[allow(deprecated)]
17488    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17489    where
17490        S: serde::Serializer,
17491    {
17492        use serde::ser::SerializeStruct;
17493        let mut len = 0;
17494        if self.add.is_some() {
17495            len += 1;
17496        }
17497        let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta.VectorIndexAdd", len)?;
17498        if let Some(v) = self.add.as_ref() {
17499            match v {
17500                vector_index_delta::vector_index_add::Add::Flat(v) => {
17501                    struct_ser.serialize_field("flat", v)?;
17502                }
17503                vector_index_delta::vector_index_add::Add::HnswFlat(v) => {
17504                    struct_ser.serialize_field("hnswFlat", v)?;
17505                }
17506            }
17507        }
17508        struct_ser.end()
17509    }
17510}
17511impl<'de> serde::Deserialize<'de> for vector_index_delta::VectorIndexAdd {
17512    #[allow(deprecated)]
17513    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17514    where
17515        D: serde::Deserializer<'de>,
17516    {
17517        const FIELDS: &[&str] = &[
17518            "flat",
17519            "hnsw_flat",
17520            "hnswFlat",
17521        ];
17522
17523        #[allow(clippy::enum_variant_names)]
17524        enum GeneratedField {
17525            Flat,
17526            HnswFlat,
17527        }
17528        impl<'de> serde::Deserialize<'de> for GeneratedField {
17529            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17530            where
17531                D: serde::Deserializer<'de>,
17532            {
17533                struct GeneratedVisitor;
17534
17535                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17536                    type Value = GeneratedField;
17537
17538                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17539                        write!(formatter, "expected one of: {:?}", &FIELDS)
17540                    }
17541
17542                    #[allow(unused_variables)]
17543                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17544                    where
17545                        E: serde::de::Error,
17546                    {
17547                        match value {
17548                            "flat" => Ok(GeneratedField::Flat),
17549                            "hnswFlat" | "hnsw_flat" => Ok(GeneratedField::HnswFlat),
17550                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17551                        }
17552                    }
17553                }
17554                deserializer.deserialize_identifier(GeneratedVisitor)
17555            }
17556        }
17557        struct GeneratedVisitor;
17558        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17559            type Value = vector_index_delta::VectorIndexAdd;
17560
17561            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17562                formatter.write_str("struct hummock.VectorIndexDelta.VectorIndexAdd")
17563            }
17564
17565            fn visit_map<V>(self, mut map_: V) -> std::result::Result<vector_index_delta::VectorIndexAdd, V::Error>
17566                where
17567                    V: serde::de::MapAccess<'de>,
17568            {
17569                let mut add__ = None;
17570                while let Some(k) = map_.next_key()? {
17571                    match k {
17572                        GeneratedField::Flat => {
17573                            if add__.is_some() {
17574                                return Err(serde::de::Error::duplicate_field("flat"));
17575                            }
17576                            add__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_delta::vector_index_add::Add::Flat)
17577;
17578                        }
17579                        GeneratedField::HnswFlat => {
17580                            if add__.is_some() {
17581                                return Err(serde::de::Error::duplicate_field("hnswFlat"));
17582                            }
17583                            add__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_delta::vector_index_add::Add::HnswFlat)
17584;
17585                        }
17586                    }
17587                }
17588                Ok(vector_index_delta::VectorIndexAdd {
17589                    add: add__,
17590                })
17591            }
17592        }
17593        deserializer.deserialize_struct("hummock.VectorIndexDelta.VectorIndexAdd", FIELDS, GeneratedVisitor)
17594    }
17595}
17596impl serde::Serialize for vector_index_delta::VectorIndexAdds {
17597    #[allow(deprecated)]
17598    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17599    where
17600        S: serde::Serializer,
17601    {
17602        use serde::ser::SerializeStruct;
17603        let mut len = 0;
17604        if !self.adds.is_empty() {
17605            len += 1;
17606        }
17607        let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta.VectorIndexAdds", len)?;
17608        if !self.adds.is_empty() {
17609            struct_ser.serialize_field("adds", &self.adds)?;
17610        }
17611        struct_ser.end()
17612    }
17613}
17614impl<'de> serde::Deserialize<'de> for vector_index_delta::VectorIndexAdds {
17615    #[allow(deprecated)]
17616    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17617    where
17618        D: serde::Deserializer<'de>,
17619    {
17620        const FIELDS: &[&str] = &[
17621            "adds",
17622        ];
17623
17624        #[allow(clippy::enum_variant_names)]
17625        enum GeneratedField {
17626            Adds,
17627        }
17628        impl<'de> serde::Deserialize<'de> for GeneratedField {
17629            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17630            where
17631                D: serde::Deserializer<'de>,
17632            {
17633                struct GeneratedVisitor;
17634
17635                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17636                    type Value = GeneratedField;
17637
17638                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17639                        write!(formatter, "expected one of: {:?}", &FIELDS)
17640                    }
17641
17642                    #[allow(unused_variables)]
17643                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17644                    where
17645                        E: serde::de::Error,
17646                    {
17647                        match value {
17648                            "adds" => Ok(GeneratedField::Adds),
17649                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17650                        }
17651                    }
17652                }
17653                deserializer.deserialize_identifier(GeneratedVisitor)
17654            }
17655        }
17656        struct GeneratedVisitor;
17657        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17658            type Value = vector_index_delta::VectorIndexAdds;
17659
17660            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17661                formatter.write_str("struct hummock.VectorIndexDelta.VectorIndexAdds")
17662            }
17663
17664            fn visit_map<V>(self, mut map_: V) -> std::result::Result<vector_index_delta::VectorIndexAdds, V::Error>
17665                where
17666                    V: serde::de::MapAccess<'de>,
17667            {
17668                let mut adds__ = None;
17669                while let Some(k) = map_.next_key()? {
17670                    match k {
17671                        GeneratedField::Adds => {
17672                            if adds__.is_some() {
17673                                return Err(serde::de::Error::duplicate_field("adds"));
17674                            }
17675                            adds__ = Some(map_.next_value()?);
17676                        }
17677                    }
17678                }
17679                Ok(vector_index_delta::VectorIndexAdds {
17680                    adds: adds__.unwrap_or_default(),
17681                })
17682            }
17683        }
17684        deserializer.deserialize_struct("hummock.VectorIndexDelta.VectorIndexAdds", FIELDS, GeneratedVisitor)
17685    }
17686}
17687impl serde::Serialize for vector_index_delta::VectorIndexInit {
17688    #[allow(deprecated)]
17689    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17690    where
17691        S: serde::Serializer,
17692    {
17693        use serde::ser::SerializeStruct;
17694        let mut len = 0;
17695        if self.info.is_some() {
17696            len += 1;
17697        }
17698        let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta.VectorIndexInit", len)?;
17699        if let Some(v) = self.info.as_ref() {
17700            struct_ser.serialize_field("info", v)?;
17701        }
17702        struct_ser.end()
17703    }
17704}
17705impl<'de> serde::Deserialize<'de> for vector_index_delta::VectorIndexInit {
17706    #[allow(deprecated)]
17707    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17708    where
17709        D: serde::Deserializer<'de>,
17710    {
17711        const FIELDS: &[&str] = &[
17712            "info",
17713        ];
17714
17715        #[allow(clippy::enum_variant_names)]
17716        enum GeneratedField {
17717            Info,
17718        }
17719        impl<'de> serde::Deserialize<'de> for GeneratedField {
17720            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17721            where
17722                D: serde::Deserializer<'de>,
17723            {
17724                struct GeneratedVisitor;
17725
17726                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17727                    type Value = GeneratedField;
17728
17729                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17730                        write!(formatter, "expected one of: {:?}", &FIELDS)
17731                    }
17732
17733                    #[allow(unused_variables)]
17734                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17735                    where
17736                        E: serde::de::Error,
17737                    {
17738                        match value {
17739                            "info" => Ok(GeneratedField::Info),
17740                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17741                        }
17742                    }
17743                }
17744                deserializer.deserialize_identifier(GeneratedVisitor)
17745            }
17746        }
17747        struct GeneratedVisitor;
17748        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17749            type Value = vector_index_delta::VectorIndexInit;
17750
17751            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17752                formatter.write_str("struct hummock.VectorIndexDelta.VectorIndexInit")
17753            }
17754
17755            fn visit_map<V>(self, mut map_: V) -> std::result::Result<vector_index_delta::VectorIndexInit, V::Error>
17756                where
17757                    V: serde::de::MapAccess<'de>,
17758            {
17759                let mut info__ = None;
17760                while let Some(k) = map_.next_key()? {
17761                    match k {
17762                        GeneratedField::Info => {
17763                            if info__.is_some() {
17764                                return Err(serde::de::Error::duplicate_field("info"));
17765                            }
17766                            info__ = map_.next_value()?;
17767                        }
17768                    }
17769                }
17770                Ok(vector_index_delta::VectorIndexInit {
17771                    info: info__,
17772                })
17773            }
17774        }
17775        deserializer.deserialize_struct("hummock.VectorIndexDelta.VectorIndexInit", FIELDS, GeneratedVisitor)
17776    }
17777}
17778impl serde::Serialize for VectorIndexObject {
17779    #[allow(deprecated)]
17780    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17781    where
17782        S: serde::Serializer,
17783    {
17784        use serde::ser::SerializeStruct;
17785        let mut len = 0;
17786        if self.id != 0 {
17787            len += 1;
17788        }
17789        if self.object_type != 0 {
17790            len += 1;
17791        }
17792        let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexObject", len)?;
17793        if self.id != 0 {
17794            #[allow(clippy::needless_borrow)]
17795            #[allow(clippy::needless_borrows_for_generic_args)]
17796            struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
17797        }
17798        if self.object_type != 0 {
17799            let v = VectorIndexObjectType::try_from(self.object_type)
17800                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.object_type)))?;
17801            struct_ser.serialize_field("objectType", &v)?;
17802        }
17803        struct_ser.end()
17804    }
17805}
17806impl<'de> serde::Deserialize<'de> for VectorIndexObject {
17807    #[allow(deprecated)]
17808    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17809    where
17810        D: serde::Deserializer<'de>,
17811    {
17812        const FIELDS: &[&str] = &[
17813            "id",
17814            "object_type",
17815            "objectType",
17816        ];
17817
17818        #[allow(clippy::enum_variant_names)]
17819        enum GeneratedField {
17820            Id,
17821            ObjectType,
17822        }
17823        impl<'de> serde::Deserialize<'de> for GeneratedField {
17824            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17825            where
17826                D: serde::Deserializer<'de>,
17827            {
17828                struct GeneratedVisitor;
17829
17830                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17831                    type Value = GeneratedField;
17832
17833                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17834                        write!(formatter, "expected one of: {:?}", &FIELDS)
17835                    }
17836
17837                    #[allow(unused_variables)]
17838                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17839                    where
17840                        E: serde::de::Error,
17841                    {
17842                        match value {
17843                            "id" => Ok(GeneratedField::Id),
17844                            "objectType" | "object_type" => Ok(GeneratedField::ObjectType),
17845                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17846                        }
17847                    }
17848                }
17849                deserializer.deserialize_identifier(GeneratedVisitor)
17850            }
17851        }
17852        struct GeneratedVisitor;
17853        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17854            type Value = VectorIndexObject;
17855
17856            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17857                formatter.write_str("struct hummock.VectorIndexObject")
17858            }
17859
17860            fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexObject, V::Error>
17861                where
17862                    V: serde::de::MapAccess<'de>,
17863            {
17864                let mut id__ = None;
17865                let mut object_type__ = None;
17866                while let Some(k) = map_.next_key()? {
17867                    match k {
17868                        GeneratedField::Id => {
17869                            if id__.is_some() {
17870                                return Err(serde::de::Error::duplicate_field("id"));
17871                            }
17872                            id__ = 
17873                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17874                            ;
17875                        }
17876                        GeneratedField::ObjectType => {
17877                            if object_type__.is_some() {
17878                                return Err(serde::de::Error::duplicate_field("objectType"));
17879                            }
17880                            object_type__ = Some(map_.next_value::<VectorIndexObjectType>()? as i32);
17881                        }
17882                    }
17883                }
17884                Ok(VectorIndexObject {
17885                    id: id__.unwrap_or_default(),
17886                    object_type: object_type__.unwrap_or_default(),
17887                })
17888            }
17889        }
17890        deserializer.deserialize_struct("hummock.VectorIndexObject", FIELDS, GeneratedVisitor)
17891    }
17892}
17893impl serde::Serialize for VectorIndexObjectType {
17894    #[allow(deprecated)]
17895    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17896    where
17897        S: serde::Serializer,
17898    {
17899        let variant = match self {
17900            Self::VectorIndexObjectUnspecified => "VECTOR_INDEX_OBJECT_UNSPECIFIED",
17901            Self::VectorIndexObjectVector => "VECTOR_INDEX_OBJECT_VECTOR",
17902            Self::VectorIndexObjectHnswGraph => "VECTOR_INDEX_OBJECT_HNSW_GRAPH",
17903        };
17904        serializer.serialize_str(variant)
17905    }
17906}
17907impl<'de> serde::Deserialize<'de> for VectorIndexObjectType {
17908    #[allow(deprecated)]
17909    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17910    where
17911        D: serde::Deserializer<'de>,
17912    {
17913        const FIELDS: &[&str] = &[
17914            "VECTOR_INDEX_OBJECT_UNSPECIFIED",
17915            "VECTOR_INDEX_OBJECT_VECTOR",
17916            "VECTOR_INDEX_OBJECT_HNSW_GRAPH",
17917        ];
17918
17919        struct GeneratedVisitor;
17920
17921        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17922            type Value = VectorIndexObjectType;
17923
17924            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17925                write!(formatter, "expected one of: {:?}", &FIELDS)
17926            }
17927
17928            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
17929            where
17930                E: serde::de::Error,
17931            {
17932                i32::try_from(v)
17933                    .ok()
17934                    .and_then(|x| x.try_into().ok())
17935                    .ok_or_else(|| {
17936                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
17937                    })
17938            }
17939
17940            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
17941            where
17942                E: serde::de::Error,
17943            {
17944                i32::try_from(v)
17945                    .ok()
17946                    .and_then(|x| x.try_into().ok())
17947                    .ok_or_else(|| {
17948                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
17949                    })
17950            }
17951
17952            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
17953            where
17954                E: serde::de::Error,
17955            {
17956                match value {
17957                    "VECTOR_INDEX_OBJECT_UNSPECIFIED" => Ok(VectorIndexObjectType::VectorIndexObjectUnspecified),
17958                    "VECTOR_INDEX_OBJECT_VECTOR" => Ok(VectorIndexObjectType::VectorIndexObjectVector),
17959                    "VECTOR_INDEX_OBJECT_HNSW_GRAPH" => Ok(VectorIndexObjectType::VectorIndexObjectHnswGraph),
17960                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
17961                }
17962            }
17963        }
17964        deserializer.deserialize_any(GeneratedVisitor)
17965    }
17966}
17967impl serde::Serialize for VersionUpdatePayload {
17968    #[allow(deprecated)]
17969    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17970    where
17971        S: serde::Serializer,
17972    {
17973        use serde::ser::SerializeStruct;
17974        let mut len = 0;
17975        if self.payload.is_some() {
17976            len += 1;
17977        }
17978        let mut struct_ser = serializer.serialize_struct("hummock.VersionUpdatePayload", len)?;
17979        if let Some(v) = self.payload.as_ref() {
17980            match v {
17981                version_update_payload::Payload::VersionDeltas(v) => {
17982                    struct_ser.serialize_field("versionDeltas", v)?;
17983                }
17984                version_update_payload::Payload::PinnedVersion(v) => {
17985                    struct_ser.serialize_field("pinnedVersion", v)?;
17986                }
17987            }
17988        }
17989        struct_ser.end()
17990    }
17991}
17992impl<'de> serde::Deserialize<'de> for VersionUpdatePayload {
17993    #[allow(deprecated)]
17994    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17995    where
17996        D: serde::Deserializer<'de>,
17997    {
17998        const FIELDS: &[&str] = &[
17999            "version_deltas",
18000            "versionDeltas",
18001            "pinned_version",
18002            "pinnedVersion",
18003        ];
18004
18005        #[allow(clippy::enum_variant_names)]
18006        enum GeneratedField {
18007            VersionDeltas,
18008            PinnedVersion,
18009        }
18010        impl<'de> serde::Deserialize<'de> for GeneratedField {
18011            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18012            where
18013                D: serde::Deserializer<'de>,
18014            {
18015                struct GeneratedVisitor;
18016
18017                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18018                    type Value = GeneratedField;
18019
18020                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18021                        write!(formatter, "expected one of: {:?}", &FIELDS)
18022                    }
18023
18024                    #[allow(unused_variables)]
18025                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18026                    where
18027                        E: serde::de::Error,
18028                    {
18029                        match value {
18030                            "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
18031                            "pinnedVersion" | "pinned_version" => Ok(GeneratedField::PinnedVersion),
18032                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18033                        }
18034                    }
18035                }
18036                deserializer.deserialize_identifier(GeneratedVisitor)
18037            }
18038        }
18039        struct GeneratedVisitor;
18040        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18041            type Value = VersionUpdatePayload;
18042
18043            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18044                formatter.write_str("struct hummock.VersionUpdatePayload")
18045            }
18046
18047            fn visit_map<V>(self, mut map_: V) -> std::result::Result<VersionUpdatePayload, V::Error>
18048                where
18049                    V: serde::de::MapAccess<'de>,
18050            {
18051                let mut payload__ = None;
18052                while let Some(k) = map_.next_key()? {
18053                    match k {
18054                        GeneratedField::VersionDeltas => {
18055                            if payload__.is_some() {
18056                                return Err(serde::de::Error::duplicate_field("versionDeltas"));
18057                            }
18058                            payload__ = map_.next_value::<::std::option::Option<_>>()?.map(version_update_payload::Payload::VersionDeltas)
18059;
18060                        }
18061                        GeneratedField::PinnedVersion => {
18062                            if payload__.is_some() {
18063                                return Err(serde::de::Error::duplicate_field("pinnedVersion"));
18064                            }
18065                            payload__ = map_.next_value::<::std::option::Option<_>>()?.map(version_update_payload::Payload::PinnedVersion)
18066;
18067                        }
18068                    }
18069                }
18070                Ok(VersionUpdatePayload {
18071                    payload: payload__,
18072                })
18073            }
18074        }
18075        deserializer.deserialize_struct("hummock.VersionUpdatePayload", FIELDS, GeneratedVisitor)
18076    }
18077}
18078impl serde::Serialize for VnodeWatermark {
18079    #[allow(deprecated)]
18080    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18081    where
18082        S: serde::Serializer,
18083    {
18084        use serde::ser::SerializeStruct;
18085        let mut len = 0;
18086        if !self.watermark.is_empty() {
18087            len += 1;
18088        }
18089        if self.vnode_bitmap.is_some() {
18090            len += 1;
18091        }
18092        let mut struct_ser = serializer.serialize_struct("hummock.VnodeWatermark", len)?;
18093        if !self.watermark.is_empty() {
18094            #[allow(clippy::needless_borrow)]
18095            #[allow(clippy::needless_borrows_for_generic_args)]
18096            struct_ser.serialize_field("watermark", pbjson::private::base64::encode(&self.watermark).as_str())?;
18097        }
18098        if let Some(v) = self.vnode_bitmap.as_ref() {
18099            struct_ser.serialize_field("vnodeBitmap", v)?;
18100        }
18101        struct_ser.end()
18102    }
18103}
18104impl<'de> serde::Deserialize<'de> for VnodeWatermark {
18105    #[allow(deprecated)]
18106    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18107    where
18108        D: serde::Deserializer<'de>,
18109    {
18110        const FIELDS: &[&str] = &[
18111            "watermark",
18112            "vnode_bitmap",
18113            "vnodeBitmap",
18114        ];
18115
18116        #[allow(clippy::enum_variant_names)]
18117        enum GeneratedField {
18118            Watermark,
18119            VnodeBitmap,
18120        }
18121        impl<'de> serde::Deserialize<'de> for GeneratedField {
18122            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18123            where
18124                D: serde::Deserializer<'de>,
18125            {
18126                struct GeneratedVisitor;
18127
18128                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18129                    type Value = GeneratedField;
18130
18131                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18132                        write!(formatter, "expected one of: {:?}", &FIELDS)
18133                    }
18134
18135                    #[allow(unused_variables)]
18136                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18137                    where
18138                        E: serde::de::Error,
18139                    {
18140                        match value {
18141                            "watermark" => Ok(GeneratedField::Watermark),
18142                            "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
18143                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18144                        }
18145                    }
18146                }
18147                deserializer.deserialize_identifier(GeneratedVisitor)
18148            }
18149        }
18150        struct GeneratedVisitor;
18151        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18152            type Value = VnodeWatermark;
18153
18154            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18155                formatter.write_str("struct hummock.VnodeWatermark")
18156            }
18157
18158            fn visit_map<V>(self, mut map_: V) -> std::result::Result<VnodeWatermark, V::Error>
18159                where
18160                    V: serde::de::MapAccess<'de>,
18161            {
18162                let mut watermark__ = None;
18163                let mut vnode_bitmap__ = None;
18164                while let Some(k) = map_.next_key()? {
18165                    match k {
18166                        GeneratedField::Watermark => {
18167                            if watermark__.is_some() {
18168                                return Err(serde::de::Error::duplicate_field("watermark"));
18169                            }
18170                            watermark__ = 
18171                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
18172                            ;
18173                        }
18174                        GeneratedField::VnodeBitmap => {
18175                            if vnode_bitmap__.is_some() {
18176                                return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
18177                            }
18178                            vnode_bitmap__ = map_.next_value()?;
18179                        }
18180                    }
18181                }
18182                Ok(VnodeWatermark {
18183                    watermark: watermark__.unwrap_or_default(),
18184                    vnode_bitmap: vnode_bitmap__,
18185                })
18186            }
18187        }
18188        deserializer.deserialize_struct("hummock.VnodeWatermark", FIELDS, GeneratedVisitor)
18189    }
18190}
18191impl serde::Serialize for WriteLimits {
18192    #[allow(deprecated)]
18193    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18194    where
18195        S: serde::Serializer,
18196    {
18197        use serde::ser::SerializeStruct;
18198        let mut len = 0;
18199        if !self.write_limits.is_empty() {
18200            len += 1;
18201        }
18202        let mut struct_ser = serializer.serialize_struct("hummock.WriteLimits", len)?;
18203        if !self.write_limits.is_empty() {
18204            struct_ser.serialize_field("writeLimits", &self.write_limits)?;
18205        }
18206        struct_ser.end()
18207    }
18208}
18209impl<'de> serde::Deserialize<'de> for WriteLimits {
18210    #[allow(deprecated)]
18211    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18212    where
18213        D: serde::Deserializer<'de>,
18214    {
18215        const FIELDS: &[&str] = &[
18216            "write_limits",
18217            "writeLimits",
18218        ];
18219
18220        #[allow(clippy::enum_variant_names)]
18221        enum GeneratedField {
18222            WriteLimits,
18223        }
18224        impl<'de> serde::Deserialize<'de> for GeneratedField {
18225            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18226            where
18227                D: serde::Deserializer<'de>,
18228            {
18229                struct GeneratedVisitor;
18230
18231                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18232                    type Value = GeneratedField;
18233
18234                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18235                        write!(formatter, "expected one of: {:?}", &FIELDS)
18236                    }
18237
18238                    #[allow(unused_variables)]
18239                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18240                    where
18241                        E: serde::de::Error,
18242                    {
18243                        match value {
18244                            "writeLimits" | "write_limits" => Ok(GeneratedField::WriteLimits),
18245                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18246                        }
18247                    }
18248                }
18249                deserializer.deserialize_identifier(GeneratedVisitor)
18250            }
18251        }
18252        struct GeneratedVisitor;
18253        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18254            type Value = WriteLimits;
18255
18256            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18257                formatter.write_str("struct hummock.WriteLimits")
18258            }
18259
18260            fn visit_map<V>(self, mut map_: V) -> std::result::Result<WriteLimits, V::Error>
18261                where
18262                    V: serde::de::MapAccess<'de>,
18263            {
18264                let mut write_limits__ = None;
18265                while let Some(k) = map_.next_key()? {
18266                    match k {
18267                        GeneratedField::WriteLimits => {
18268                            if write_limits__.is_some() {
18269                                return Err(serde::de::Error::duplicate_field("writeLimits"));
18270                            }
18271                            write_limits__ = Some(
18272                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
18273                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
18274                            );
18275                        }
18276                    }
18277                }
18278                Ok(WriteLimits {
18279                    write_limits: write_limits__.unwrap_or_default(),
18280                })
18281            }
18282        }
18283        deserializer.deserialize_struct("hummock.WriteLimits", FIELDS, GeneratedVisitor)
18284    }
18285}
18286impl serde::Serialize for write_limits::WriteLimit {
18287    #[allow(deprecated)]
18288    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
18289    where
18290        S: serde::Serializer,
18291    {
18292        use serde::ser::SerializeStruct;
18293        let mut len = 0;
18294        if !self.table_ids.is_empty() {
18295            len += 1;
18296        }
18297        if !self.reason.is_empty() {
18298            len += 1;
18299        }
18300        let mut struct_ser = serializer.serialize_struct("hummock.WriteLimits.WriteLimit", len)?;
18301        if !self.table_ids.is_empty() {
18302            struct_ser.serialize_field("tableIds", &self.table_ids)?;
18303        }
18304        if !self.reason.is_empty() {
18305            struct_ser.serialize_field("reason", &self.reason)?;
18306        }
18307        struct_ser.end()
18308    }
18309}
18310impl<'de> serde::Deserialize<'de> for write_limits::WriteLimit {
18311    #[allow(deprecated)]
18312    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
18313    where
18314        D: serde::Deserializer<'de>,
18315    {
18316        const FIELDS: &[&str] = &[
18317            "table_ids",
18318            "tableIds",
18319            "reason",
18320        ];
18321
18322        #[allow(clippy::enum_variant_names)]
18323        enum GeneratedField {
18324            TableIds,
18325            Reason,
18326        }
18327        impl<'de> serde::Deserialize<'de> for GeneratedField {
18328            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
18329            where
18330                D: serde::Deserializer<'de>,
18331            {
18332                struct GeneratedVisitor;
18333
18334                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18335                    type Value = GeneratedField;
18336
18337                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18338                        write!(formatter, "expected one of: {:?}", &FIELDS)
18339                    }
18340
18341                    #[allow(unused_variables)]
18342                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
18343                    where
18344                        E: serde::de::Error,
18345                    {
18346                        match value {
18347                            "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
18348                            "reason" => Ok(GeneratedField::Reason),
18349                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
18350                        }
18351                    }
18352                }
18353                deserializer.deserialize_identifier(GeneratedVisitor)
18354            }
18355        }
18356        struct GeneratedVisitor;
18357        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
18358            type Value = write_limits::WriteLimit;
18359
18360            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18361                formatter.write_str("struct hummock.WriteLimits.WriteLimit")
18362            }
18363
18364            fn visit_map<V>(self, mut map_: V) -> std::result::Result<write_limits::WriteLimit, V::Error>
18365                where
18366                    V: serde::de::MapAccess<'de>,
18367            {
18368                let mut table_ids__ = None;
18369                let mut reason__ = None;
18370                while let Some(k) = map_.next_key()? {
18371                    match k {
18372                        GeneratedField::TableIds => {
18373                            if table_ids__.is_some() {
18374                                return Err(serde::de::Error::duplicate_field("tableIds"));
18375                            }
18376                            table_ids__ = 
18377                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
18378                                    .into_iter().map(|x| x.0).collect())
18379                            ;
18380                        }
18381                        GeneratedField::Reason => {
18382                            if reason__.is_some() {
18383                                return Err(serde::de::Error::duplicate_field("reason"));
18384                            }
18385                            reason__ = Some(map_.next_value()?);
18386                        }
18387                    }
18388                }
18389                Ok(write_limits::WriteLimit {
18390                    table_ids: table_ids__.unwrap_or_default(),
18391                    reason: reason__.unwrap_or_default(),
18392                })
18393            }
18394        }
18395        deserializer.deserialize_struct("hummock.WriteLimits.WriteLimit", FIELDS, GeneratedVisitor)
18396    }
18397}