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 DistanceType {
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        let variant = match self {
3036            Self::Unspecified => "DISTANCE_TYPE_UNSPECIFIED",
3037            Self::L1 => "DISTANCE_TYPE_L1",
3038            Self::L2 => "DISTANCE_TYPE_L2",
3039            Self::Cosine => "DISTANCE_TYPE_COSINE",
3040            Self::InnerProduct => "DISTANCE_TYPE_INNER_PRODUCT",
3041        };
3042        serializer.serialize_str(variant)
3043    }
3044}
3045impl<'de> serde::Deserialize<'de> for DistanceType {
3046    #[allow(deprecated)]
3047    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3048    where
3049        D: serde::Deserializer<'de>,
3050    {
3051        const FIELDS: &[&str] = &[
3052            "DISTANCE_TYPE_UNSPECIFIED",
3053            "DISTANCE_TYPE_L1",
3054            "DISTANCE_TYPE_L2",
3055            "DISTANCE_TYPE_COSINE",
3056            "DISTANCE_TYPE_INNER_PRODUCT",
3057        ];
3058
3059        struct GeneratedVisitor;
3060
3061        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3062            type Value = DistanceType;
3063
3064            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3065                write!(formatter, "expected one of: {:?}", &FIELDS)
3066            }
3067
3068            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3069            where
3070                E: serde::de::Error,
3071            {
3072                i32::try_from(v)
3073                    .ok()
3074                    .and_then(|x| x.try_into().ok())
3075                    .ok_or_else(|| {
3076                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3077                    })
3078            }
3079
3080            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3081            where
3082                E: serde::de::Error,
3083            {
3084                i32::try_from(v)
3085                    .ok()
3086                    .and_then(|x| x.try_into().ok())
3087                    .ok_or_else(|| {
3088                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3089                    })
3090            }
3091
3092            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3093            where
3094                E: serde::de::Error,
3095            {
3096                match value {
3097                    "DISTANCE_TYPE_UNSPECIFIED" => Ok(DistanceType::Unspecified),
3098                    "DISTANCE_TYPE_L1" => Ok(DistanceType::L1),
3099                    "DISTANCE_TYPE_L2" => Ok(DistanceType::L2),
3100                    "DISTANCE_TYPE_COSINE" => Ok(DistanceType::Cosine),
3101                    "DISTANCE_TYPE_INNER_PRODUCT" => Ok(DistanceType::InnerProduct),
3102                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3103                }
3104            }
3105        }
3106        deserializer.deserialize_any(GeneratedVisitor)
3107    }
3108}
3109impl serde::Serialize for EpochNewChangeLog {
3110    #[allow(deprecated)]
3111    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3112    where
3113        S: serde::Serializer,
3114    {
3115        use serde::ser::SerializeStruct;
3116        let mut len = 0;
3117        if !self.old_value.is_empty() {
3118            len += 1;
3119        }
3120        if !self.new_value.is_empty() {
3121            len += 1;
3122        }
3123        if !self.epochs.is_empty() {
3124            len += 1;
3125        }
3126        let mut struct_ser = serializer.serialize_struct("hummock.EpochNewChangeLog", len)?;
3127        if !self.old_value.is_empty() {
3128            struct_ser.serialize_field("oldValue", &self.old_value)?;
3129        }
3130        if !self.new_value.is_empty() {
3131            struct_ser.serialize_field("newValue", &self.new_value)?;
3132        }
3133        if !self.epochs.is_empty() {
3134            struct_ser.serialize_field("epochs", &self.epochs.iter().map(ToString::to_string).collect::<Vec<_>>())?;
3135        }
3136        struct_ser.end()
3137    }
3138}
3139impl<'de> serde::Deserialize<'de> for EpochNewChangeLog {
3140    #[allow(deprecated)]
3141    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3142    where
3143        D: serde::Deserializer<'de>,
3144    {
3145        const FIELDS: &[&str] = &[
3146            "old_value",
3147            "oldValue",
3148            "new_value",
3149            "newValue",
3150            "epochs",
3151        ];
3152
3153        #[allow(clippy::enum_variant_names)]
3154        enum GeneratedField {
3155            OldValue,
3156            NewValue,
3157            Epochs,
3158        }
3159        impl<'de> serde::Deserialize<'de> for GeneratedField {
3160            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3161            where
3162                D: serde::Deserializer<'de>,
3163            {
3164                struct GeneratedVisitor;
3165
3166                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3167                    type Value = GeneratedField;
3168
3169                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3170                        write!(formatter, "expected one of: {:?}", &FIELDS)
3171                    }
3172
3173                    #[allow(unused_variables)]
3174                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3175                    where
3176                        E: serde::de::Error,
3177                    {
3178                        match value {
3179                            "oldValue" | "old_value" => Ok(GeneratedField::OldValue),
3180                            "newValue" | "new_value" => Ok(GeneratedField::NewValue),
3181                            "epochs" => Ok(GeneratedField::Epochs),
3182                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3183                        }
3184                    }
3185                }
3186                deserializer.deserialize_identifier(GeneratedVisitor)
3187            }
3188        }
3189        struct GeneratedVisitor;
3190        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3191            type Value = EpochNewChangeLog;
3192
3193            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3194                formatter.write_str("struct hummock.EpochNewChangeLog")
3195            }
3196
3197            fn visit_map<V>(self, mut map_: V) -> std::result::Result<EpochNewChangeLog, V::Error>
3198                where
3199                    V: serde::de::MapAccess<'de>,
3200            {
3201                let mut old_value__ = None;
3202                let mut new_value__ = None;
3203                let mut epochs__ = None;
3204                while let Some(k) = map_.next_key()? {
3205                    match k {
3206                        GeneratedField::OldValue => {
3207                            if old_value__.is_some() {
3208                                return Err(serde::de::Error::duplicate_field("oldValue"));
3209                            }
3210                            old_value__ = Some(map_.next_value()?);
3211                        }
3212                        GeneratedField::NewValue => {
3213                            if new_value__.is_some() {
3214                                return Err(serde::de::Error::duplicate_field("newValue"));
3215                            }
3216                            new_value__ = Some(map_.next_value()?);
3217                        }
3218                        GeneratedField::Epochs => {
3219                            if epochs__.is_some() {
3220                                return Err(serde::de::Error::duplicate_field("epochs"));
3221                            }
3222                            epochs__ = 
3223                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3224                                    .into_iter().map(|x| x.0).collect())
3225                            ;
3226                        }
3227                    }
3228                }
3229                Ok(EpochNewChangeLog {
3230                    old_value: old_value__.unwrap_or_default(),
3231                    new_value: new_value__.unwrap_or_default(),
3232                    epochs: epochs__.unwrap_or_default(),
3233                })
3234            }
3235        }
3236        deserializer.deserialize_struct("hummock.EpochNewChangeLog", FIELDS, GeneratedVisitor)
3237    }
3238}
3239impl serde::Serialize for FlatIndex {
3240    #[allow(deprecated)]
3241    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3242    where
3243        S: serde::Serializer,
3244    {
3245        use serde::ser::SerializeStruct;
3246        let mut len = 0;
3247        if self.config.is_some() {
3248            len += 1;
3249        }
3250        if !self.vector_files.is_empty() {
3251            len += 1;
3252        }
3253        if self.next_vector_id != 0 {
3254            len += 1;
3255        }
3256        let mut struct_ser = serializer.serialize_struct("hummock.FlatIndex", len)?;
3257        if let Some(v) = self.config.as_ref() {
3258            struct_ser.serialize_field("config", v)?;
3259        }
3260        if !self.vector_files.is_empty() {
3261            struct_ser.serialize_field("vectorFiles", &self.vector_files)?;
3262        }
3263        if self.next_vector_id != 0 {
3264            #[allow(clippy::needless_borrow)]
3265            #[allow(clippy::needless_borrows_for_generic_args)]
3266            struct_ser.serialize_field("nextVectorId", ToString::to_string(&self.next_vector_id).as_str())?;
3267        }
3268        struct_ser.end()
3269    }
3270}
3271impl<'de> serde::Deserialize<'de> for FlatIndex {
3272    #[allow(deprecated)]
3273    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3274    where
3275        D: serde::Deserializer<'de>,
3276    {
3277        const FIELDS: &[&str] = &[
3278            "config",
3279            "vector_files",
3280            "vectorFiles",
3281            "next_vector_id",
3282            "nextVectorId",
3283        ];
3284
3285        #[allow(clippy::enum_variant_names)]
3286        enum GeneratedField {
3287            Config,
3288            VectorFiles,
3289            NextVectorId,
3290        }
3291        impl<'de> serde::Deserialize<'de> for GeneratedField {
3292            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3293            where
3294                D: serde::Deserializer<'de>,
3295            {
3296                struct GeneratedVisitor;
3297
3298                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3299                    type Value = GeneratedField;
3300
3301                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3302                        write!(formatter, "expected one of: {:?}", &FIELDS)
3303                    }
3304
3305                    #[allow(unused_variables)]
3306                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3307                    where
3308                        E: serde::de::Error,
3309                    {
3310                        match value {
3311                            "config" => Ok(GeneratedField::Config),
3312                            "vectorFiles" | "vector_files" => Ok(GeneratedField::VectorFiles),
3313                            "nextVectorId" | "next_vector_id" => Ok(GeneratedField::NextVectorId),
3314                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3315                        }
3316                    }
3317                }
3318                deserializer.deserialize_identifier(GeneratedVisitor)
3319            }
3320        }
3321        struct GeneratedVisitor;
3322        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3323            type Value = FlatIndex;
3324
3325            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3326                formatter.write_str("struct hummock.FlatIndex")
3327            }
3328
3329            fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlatIndex, V::Error>
3330                where
3331                    V: serde::de::MapAccess<'de>,
3332            {
3333                let mut config__ = None;
3334                let mut vector_files__ = None;
3335                let mut next_vector_id__ = None;
3336                while let Some(k) = map_.next_key()? {
3337                    match k {
3338                        GeneratedField::Config => {
3339                            if config__.is_some() {
3340                                return Err(serde::de::Error::duplicate_field("config"));
3341                            }
3342                            config__ = map_.next_value()?;
3343                        }
3344                        GeneratedField::VectorFiles => {
3345                            if vector_files__.is_some() {
3346                                return Err(serde::de::Error::duplicate_field("vectorFiles"));
3347                            }
3348                            vector_files__ = Some(map_.next_value()?);
3349                        }
3350                        GeneratedField::NextVectorId => {
3351                            if next_vector_id__.is_some() {
3352                                return Err(serde::de::Error::duplicate_field("nextVectorId"));
3353                            }
3354                            next_vector_id__ = 
3355                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3356                            ;
3357                        }
3358                    }
3359                }
3360                Ok(FlatIndex {
3361                    config: config__,
3362                    vector_files: vector_files__.unwrap_or_default(),
3363                    next_vector_id: next_vector_id__.unwrap_or_default(),
3364                })
3365            }
3366        }
3367        deserializer.deserialize_struct("hummock.FlatIndex", FIELDS, GeneratedVisitor)
3368    }
3369}
3370impl serde::Serialize for FlatIndexAdd {
3371    #[allow(deprecated)]
3372    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3373    where
3374        S: serde::Serializer,
3375    {
3376        use serde::ser::SerializeStruct;
3377        let mut len = 0;
3378        if !self.added_vector_files.is_empty() {
3379            len += 1;
3380        }
3381        if self.next_vector_id != 0 {
3382            len += 1;
3383        }
3384        let mut struct_ser = serializer.serialize_struct("hummock.FlatIndexAdd", len)?;
3385        if !self.added_vector_files.is_empty() {
3386            struct_ser.serialize_field("addedVectorFiles", &self.added_vector_files)?;
3387        }
3388        if self.next_vector_id != 0 {
3389            #[allow(clippy::needless_borrow)]
3390            #[allow(clippy::needless_borrows_for_generic_args)]
3391            struct_ser.serialize_field("nextVectorId", ToString::to_string(&self.next_vector_id).as_str())?;
3392        }
3393        struct_ser.end()
3394    }
3395}
3396impl<'de> serde::Deserialize<'de> for FlatIndexAdd {
3397    #[allow(deprecated)]
3398    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3399    where
3400        D: serde::Deserializer<'de>,
3401    {
3402        const FIELDS: &[&str] = &[
3403            "added_vector_files",
3404            "addedVectorFiles",
3405            "next_vector_id",
3406            "nextVectorId",
3407        ];
3408
3409        #[allow(clippy::enum_variant_names)]
3410        enum GeneratedField {
3411            AddedVectorFiles,
3412            NextVectorId,
3413        }
3414        impl<'de> serde::Deserialize<'de> for GeneratedField {
3415            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3416            where
3417                D: serde::Deserializer<'de>,
3418            {
3419                struct GeneratedVisitor;
3420
3421                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3422                    type Value = GeneratedField;
3423
3424                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3425                        write!(formatter, "expected one of: {:?}", &FIELDS)
3426                    }
3427
3428                    #[allow(unused_variables)]
3429                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3430                    where
3431                        E: serde::de::Error,
3432                    {
3433                        match value {
3434                            "addedVectorFiles" | "added_vector_files" => Ok(GeneratedField::AddedVectorFiles),
3435                            "nextVectorId" | "next_vector_id" => Ok(GeneratedField::NextVectorId),
3436                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3437                        }
3438                    }
3439                }
3440                deserializer.deserialize_identifier(GeneratedVisitor)
3441            }
3442        }
3443        struct GeneratedVisitor;
3444        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3445            type Value = FlatIndexAdd;
3446
3447            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3448                formatter.write_str("struct hummock.FlatIndexAdd")
3449            }
3450
3451            fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlatIndexAdd, V::Error>
3452                where
3453                    V: serde::de::MapAccess<'de>,
3454            {
3455                let mut added_vector_files__ = None;
3456                let mut next_vector_id__ = None;
3457                while let Some(k) = map_.next_key()? {
3458                    match k {
3459                        GeneratedField::AddedVectorFiles => {
3460                            if added_vector_files__.is_some() {
3461                                return Err(serde::de::Error::duplicate_field("addedVectorFiles"));
3462                            }
3463                            added_vector_files__ = Some(map_.next_value()?);
3464                        }
3465                        GeneratedField::NextVectorId => {
3466                            if next_vector_id__.is_some() {
3467                                return Err(serde::de::Error::duplicate_field("nextVectorId"));
3468                            }
3469                            next_vector_id__ = 
3470                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3471                            ;
3472                        }
3473                    }
3474                }
3475                Ok(FlatIndexAdd {
3476                    added_vector_files: added_vector_files__.unwrap_or_default(),
3477                    next_vector_id: next_vector_id__.unwrap_or_default(),
3478                })
3479            }
3480        }
3481        deserializer.deserialize_struct("hummock.FlatIndexAdd", FIELDS, GeneratedVisitor)
3482    }
3483}
3484impl serde::Serialize for FlatIndexConfig {
3485    #[allow(deprecated)]
3486    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3487    where
3488        S: serde::Serializer,
3489    {
3490        use serde::ser::SerializeStruct;
3491        let len = 0;
3492        let struct_ser = serializer.serialize_struct("hummock.FlatIndexConfig", len)?;
3493        struct_ser.end()
3494    }
3495}
3496impl<'de> serde::Deserialize<'de> for FlatIndexConfig {
3497    #[allow(deprecated)]
3498    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3499    where
3500        D: serde::Deserializer<'de>,
3501    {
3502        const FIELDS: &[&str] = &[
3503        ];
3504
3505        #[allow(clippy::enum_variant_names)]
3506        enum GeneratedField {
3507        }
3508        impl<'de> serde::Deserialize<'de> for GeneratedField {
3509            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3510            where
3511                D: serde::Deserializer<'de>,
3512            {
3513                struct GeneratedVisitor;
3514
3515                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3516                    type Value = GeneratedField;
3517
3518                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3519                        write!(formatter, "expected one of: {:?}", &FIELDS)
3520                    }
3521
3522                    #[allow(unused_variables)]
3523                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3524                    where
3525                        E: serde::de::Error,
3526                    {
3527                            Err(serde::de::Error::unknown_field(value, FIELDS))
3528                    }
3529                }
3530                deserializer.deserialize_identifier(GeneratedVisitor)
3531            }
3532        }
3533        struct GeneratedVisitor;
3534        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3535            type Value = FlatIndexConfig;
3536
3537            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3538                formatter.write_str("struct hummock.FlatIndexConfig")
3539            }
3540
3541            fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlatIndexConfig, V::Error>
3542                where
3543                    V: serde::de::MapAccess<'de>,
3544            {
3545                while map_.next_key::<GeneratedField>()?.is_some() {
3546                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
3547                }
3548                Ok(FlatIndexConfig {
3549                })
3550            }
3551        }
3552        deserializer.deserialize_struct("hummock.FlatIndexConfig", FIELDS, GeneratedVisitor)
3553    }
3554}
3555impl serde::Serialize for FullScanTask {
3556    #[allow(deprecated)]
3557    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3558    where
3559        S: serde::Serializer,
3560    {
3561        use serde::ser::SerializeStruct;
3562        let mut len = 0;
3563        if self.sst_retention_watermark != 0 {
3564            len += 1;
3565        }
3566        if self.prefix.is_some() {
3567            len += 1;
3568        }
3569        if self.start_after.is_some() {
3570            len += 1;
3571        }
3572        if self.limit.is_some() {
3573            len += 1;
3574        }
3575        let mut struct_ser = serializer.serialize_struct("hummock.FullScanTask", len)?;
3576        if self.sst_retention_watermark != 0 {
3577            #[allow(clippy::needless_borrow)]
3578            #[allow(clippy::needless_borrows_for_generic_args)]
3579            struct_ser.serialize_field("sstRetentionWatermark", ToString::to_string(&self.sst_retention_watermark).as_str())?;
3580        }
3581        if let Some(v) = self.prefix.as_ref() {
3582            struct_ser.serialize_field("prefix", v)?;
3583        }
3584        if let Some(v) = self.start_after.as_ref() {
3585            struct_ser.serialize_field("startAfter", v)?;
3586        }
3587        if let Some(v) = self.limit.as_ref() {
3588            #[allow(clippy::needless_borrow)]
3589            #[allow(clippy::needless_borrows_for_generic_args)]
3590            struct_ser.serialize_field("limit", ToString::to_string(&v).as_str())?;
3591        }
3592        struct_ser.end()
3593    }
3594}
3595impl<'de> serde::Deserialize<'de> for FullScanTask {
3596    #[allow(deprecated)]
3597    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3598    where
3599        D: serde::Deserializer<'de>,
3600    {
3601        const FIELDS: &[&str] = &[
3602            "sst_retention_watermark",
3603            "sstRetentionWatermark",
3604            "prefix",
3605            "start_after",
3606            "startAfter",
3607            "limit",
3608        ];
3609
3610        #[allow(clippy::enum_variant_names)]
3611        enum GeneratedField {
3612            SstRetentionWatermark,
3613            Prefix,
3614            StartAfter,
3615            Limit,
3616        }
3617        impl<'de> serde::Deserialize<'de> for GeneratedField {
3618            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3619            where
3620                D: serde::Deserializer<'de>,
3621            {
3622                struct GeneratedVisitor;
3623
3624                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3625                    type Value = GeneratedField;
3626
3627                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3628                        write!(formatter, "expected one of: {:?}", &FIELDS)
3629                    }
3630
3631                    #[allow(unused_variables)]
3632                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3633                    where
3634                        E: serde::de::Error,
3635                    {
3636                        match value {
3637                            "sstRetentionWatermark" | "sst_retention_watermark" => Ok(GeneratedField::SstRetentionWatermark),
3638                            "prefix" => Ok(GeneratedField::Prefix),
3639                            "startAfter" | "start_after" => Ok(GeneratedField::StartAfter),
3640                            "limit" => Ok(GeneratedField::Limit),
3641                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3642                        }
3643                    }
3644                }
3645                deserializer.deserialize_identifier(GeneratedVisitor)
3646            }
3647        }
3648        struct GeneratedVisitor;
3649        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3650            type Value = FullScanTask;
3651
3652            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3653                formatter.write_str("struct hummock.FullScanTask")
3654            }
3655
3656            fn visit_map<V>(self, mut map_: V) -> std::result::Result<FullScanTask, V::Error>
3657                where
3658                    V: serde::de::MapAccess<'de>,
3659            {
3660                let mut sst_retention_watermark__ = None;
3661                let mut prefix__ = None;
3662                let mut start_after__ = None;
3663                let mut limit__ = None;
3664                while let Some(k) = map_.next_key()? {
3665                    match k {
3666                        GeneratedField::SstRetentionWatermark => {
3667                            if sst_retention_watermark__.is_some() {
3668                                return Err(serde::de::Error::duplicate_field("sstRetentionWatermark"));
3669                            }
3670                            sst_retention_watermark__ = 
3671                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3672                            ;
3673                        }
3674                        GeneratedField::Prefix => {
3675                            if prefix__.is_some() {
3676                                return Err(serde::de::Error::duplicate_field("prefix"));
3677                            }
3678                            prefix__ = map_.next_value()?;
3679                        }
3680                        GeneratedField::StartAfter => {
3681                            if start_after__.is_some() {
3682                                return Err(serde::de::Error::duplicate_field("startAfter"));
3683                            }
3684                            start_after__ = map_.next_value()?;
3685                        }
3686                        GeneratedField::Limit => {
3687                            if limit__.is_some() {
3688                                return Err(serde::de::Error::duplicate_field("limit"));
3689                            }
3690                            limit__ = 
3691                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3692                            ;
3693                        }
3694                    }
3695                }
3696                Ok(FullScanTask {
3697                    sst_retention_watermark: sst_retention_watermark__.unwrap_or_default(),
3698                    prefix: prefix__,
3699                    start_after: start_after__,
3700                    limit: limit__,
3701                })
3702            }
3703        }
3704        deserializer.deserialize_struct("hummock.FullScanTask", FIELDS, GeneratedVisitor)
3705    }
3706}
3707impl serde::Serialize for GetAssignedCompactTaskNumRequest {
3708    #[allow(deprecated)]
3709    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3710    where
3711        S: serde::Serializer,
3712    {
3713        use serde::ser::SerializeStruct;
3714        let len = 0;
3715        let struct_ser = serializer.serialize_struct("hummock.GetAssignedCompactTaskNumRequest", len)?;
3716        struct_ser.end()
3717    }
3718}
3719impl<'de> serde::Deserialize<'de> for GetAssignedCompactTaskNumRequest {
3720    #[allow(deprecated)]
3721    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3722    where
3723        D: serde::Deserializer<'de>,
3724    {
3725        const FIELDS: &[&str] = &[
3726        ];
3727
3728        #[allow(clippy::enum_variant_names)]
3729        enum GeneratedField {
3730        }
3731        impl<'de> serde::Deserialize<'de> for GeneratedField {
3732            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3733            where
3734                D: serde::Deserializer<'de>,
3735            {
3736                struct GeneratedVisitor;
3737
3738                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3739                    type Value = GeneratedField;
3740
3741                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3742                        write!(formatter, "expected one of: {:?}", &FIELDS)
3743                    }
3744
3745                    #[allow(unused_variables)]
3746                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3747                    where
3748                        E: serde::de::Error,
3749                    {
3750                            Err(serde::de::Error::unknown_field(value, FIELDS))
3751                    }
3752                }
3753                deserializer.deserialize_identifier(GeneratedVisitor)
3754            }
3755        }
3756        struct GeneratedVisitor;
3757        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3758            type Value = GetAssignedCompactTaskNumRequest;
3759
3760            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3761                formatter.write_str("struct hummock.GetAssignedCompactTaskNumRequest")
3762            }
3763
3764            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetAssignedCompactTaskNumRequest, V::Error>
3765                where
3766                    V: serde::de::MapAccess<'de>,
3767            {
3768                while map_.next_key::<GeneratedField>()?.is_some() {
3769                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
3770                }
3771                Ok(GetAssignedCompactTaskNumRequest {
3772                })
3773            }
3774        }
3775        deserializer.deserialize_struct("hummock.GetAssignedCompactTaskNumRequest", FIELDS, GeneratedVisitor)
3776    }
3777}
3778impl serde::Serialize for GetAssignedCompactTaskNumResponse {
3779    #[allow(deprecated)]
3780    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3781    where
3782        S: serde::Serializer,
3783    {
3784        use serde::ser::SerializeStruct;
3785        let mut len = 0;
3786        if self.num_tasks != 0 {
3787            len += 1;
3788        }
3789        let mut struct_ser = serializer.serialize_struct("hummock.GetAssignedCompactTaskNumResponse", len)?;
3790        if self.num_tasks != 0 {
3791            struct_ser.serialize_field("numTasks", &self.num_tasks)?;
3792        }
3793        struct_ser.end()
3794    }
3795}
3796impl<'de> serde::Deserialize<'de> for GetAssignedCompactTaskNumResponse {
3797    #[allow(deprecated)]
3798    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3799    where
3800        D: serde::Deserializer<'de>,
3801    {
3802        const FIELDS: &[&str] = &[
3803            "num_tasks",
3804            "numTasks",
3805        ];
3806
3807        #[allow(clippy::enum_variant_names)]
3808        enum GeneratedField {
3809            NumTasks,
3810        }
3811        impl<'de> serde::Deserialize<'de> for GeneratedField {
3812            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3813            where
3814                D: serde::Deserializer<'de>,
3815            {
3816                struct GeneratedVisitor;
3817
3818                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3819                    type Value = GeneratedField;
3820
3821                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3822                        write!(formatter, "expected one of: {:?}", &FIELDS)
3823                    }
3824
3825                    #[allow(unused_variables)]
3826                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3827                    where
3828                        E: serde::de::Error,
3829                    {
3830                        match value {
3831                            "numTasks" | "num_tasks" => Ok(GeneratedField::NumTasks),
3832                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3833                        }
3834                    }
3835                }
3836                deserializer.deserialize_identifier(GeneratedVisitor)
3837            }
3838        }
3839        struct GeneratedVisitor;
3840        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3841            type Value = GetAssignedCompactTaskNumResponse;
3842
3843            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3844                formatter.write_str("struct hummock.GetAssignedCompactTaskNumResponse")
3845            }
3846
3847            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetAssignedCompactTaskNumResponse, V::Error>
3848                where
3849                    V: serde::de::MapAccess<'de>,
3850            {
3851                let mut num_tasks__ = None;
3852                while let Some(k) = map_.next_key()? {
3853                    match k {
3854                        GeneratedField::NumTasks => {
3855                            if num_tasks__.is_some() {
3856                                return Err(serde::de::Error::duplicate_field("numTasks"));
3857                            }
3858                            num_tasks__ = 
3859                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3860                            ;
3861                        }
3862                    }
3863                }
3864                Ok(GetAssignedCompactTaskNumResponse {
3865                    num_tasks: num_tasks__.unwrap_or_default(),
3866                })
3867            }
3868        }
3869        deserializer.deserialize_struct("hummock.GetAssignedCompactTaskNumResponse", FIELDS, GeneratedVisitor)
3870    }
3871}
3872impl serde::Serialize for GetCompactionScoreRequest {
3873    #[allow(deprecated)]
3874    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3875    where
3876        S: serde::Serializer,
3877    {
3878        use serde::ser::SerializeStruct;
3879        let mut len = 0;
3880        if self.compaction_group_id != 0 {
3881            len += 1;
3882        }
3883        let mut struct_ser = serializer.serialize_struct("hummock.GetCompactionScoreRequest", len)?;
3884        if self.compaction_group_id != 0 {
3885            #[allow(clippy::needless_borrow)]
3886            #[allow(clippy::needless_borrows_for_generic_args)]
3887            struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
3888        }
3889        struct_ser.end()
3890    }
3891}
3892impl<'de> serde::Deserialize<'de> for GetCompactionScoreRequest {
3893    #[allow(deprecated)]
3894    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3895    where
3896        D: serde::Deserializer<'de>,
3897    {
3898        const FIELDS: &[&str] = &[
3899            "compaction_group_id",
3900            "compactionGroupId",
3901        ];
3902
3903        #[allow(clippy::enum_variant_names)]
3904        enum GeneratedField {
3905            CompactionGroupId,
3906        }
3907        impl<'de> serde::Deserialize<'de> for GeneratedField {
3908            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3909            where
3910                D: serde::Deserializer<'de>,
3911            {
3912                struct GeneratedVisitor;
3913
3914                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3915                    type Value = GeneratedField;
3916
3917                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3918                        write!(formatter, "expected one of: {:?}", &FIELDS)
3919                    }
3920
3921                    #[allow(unused_variables)]
3922                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3923                    where
3924                        E: serde::de::Error,
3925                    {
3926                        match value {
3927                            "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
3928                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3929                        }
3930                    }
3931                }
3932                deserializer.deserialize_identifier(GeneratedVisitor)
3933            }
3934        }
3935        struct GeneratedVisitor;
3936        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3937            type Value = GetCompactionScoreRequest;
3938
3939            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3940                formatter.write_str("struct hummock.GetCompactionScoreRequest")
3941            }
3942
3943            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCompactionScoreRequest, V::Error>
3944                where
3945                    V: serde::de::MapAccess<'de>,
3946            {
3947                let mut compaction_group_id__ = None;
3948                while let Some(k) = map_.next_key()? {
3949                    match k {
3950                        GeneratedField::CompactionGroupId => {
3951                            if compaction_group_id__.is_some() {
3952                                return Err(serde::de::Error::duplicate_field("compactionGroupId"));
3953                            }
3954                            compaction_group_id__ = 
3955                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3956                            ;
3957                        }
3958                    }
3959                }
3960                Ok(GetCompactionScoreRequest {
3961                    compaction_group_id: compaction_group_id__.unwrap_or_default(),
3962                })
3963            }
3964        }
3965        deserializer.deserialize_struct("hummock.GetCompactionScoreRequest", FIELDS, GeneratedVisitor)
3966    }
3967}
3968impl serde::Serialize for GetCompactionScoreResponse {
3969    #[allow(deprecated)]
3970    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3971    where
3972        S: serde::Serializer,
3973    {
3974        use serde::ser::SerializeStruct;
3975        let mut len = 0;
3976        if self.compaction_group_id != 0 {
3977            len += 1;
3978        }
3979        if !self.scores.is_empty() {
3980            len += 1;
3981        }
3982        let mut struct_ser = serializer.serialize_struct("hummock.GetCompactionScoreResponse", len)?;
3983        if self.compaction_group_id != 0 {
3984            #[allow(clippy::needless_borrow)]
3985            #[allow(clippy::needless_borrows_for_generic_args)]
3986            struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
3987        }
3988        if !self.scores.is_empty() {
3989            struct_ser.serialize_field("scores", &self.scores)?;
3990        }
3991        struct_ser.end()
3992    }
3993}
3994impl<'de> serde::Deserialize<'de> for GetCompactionScoreResponse {
3995    #[allow(deprecated)]
3996    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3997    where
3998        D: serde::Deserializer<'de>,
3999    {
4000        const FIELDS: &[&str] = &[
4001            "compaction_group_id",
4002            "compactionGroupId",
4003            "scores",
4004        ];
4005
4006        #[allow(clippy::enum_variant_names)]
4007        enum GeneratedField {
4008            CompactionGroupId,
4009            Scores,
4010        }
4011        impl<'de> serde::Deserialize<'de> for GeneratedField {
4012            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4013            where
4014                D: serde::Deserializer<'de>,
4015            {
4016                struct GeneratedVisitor;
4017
4018                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4019                    type Value = GeneratedField;
4020
4021                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4022                        write!(formatter, "expected one of: {:?}", &FIELDS)
4023                    }
4024
4025                    #[allow(unused_variables)]
4026                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4027                    where
4028                        E: serde::de::Error,
4029                    {
4030                        match value {
4031                            "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
4032                            "scores" => Ok(GeneratedField::Scores),
4033                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4034                        }
4035                    }
4036                }
4037                deserializer.deserialize_identifier(GeneratedVisitor)
4038            }
4039        }
4040        struct GeneratedVisitor;
4041        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4042            type Value = GetCompactionScoreResponse;
4043
4044            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4045                formatter.write_str("struct hummock.GetCompactionScoreResponse")
4046            }
4047
4048            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCompactionScoreResponse, V::Error>
4049                where
4050                    V: serde::de::MapAccess<'de>,
4051            {
4052                let mut compaction_group_id__ = None;
4053                let mut scores__ = None;
4054                while let Some(k) = map_.next_key()? {
4055                    match k {
4056                        GeneratedField::CompactionGroupId => {
4057                            if compaction_group_id__.is_some() {
4058                                return Err(serde::de::Error::duplicate_field("compactionGroupId"));
4059                            }
4060                            compaction_group_id__ = 
4061                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4062                            ;
4063                        }
4064                        GeneratedField::Scores => {
4065                            if scores__.is_some() {
4066                                return Err(serde::de::Error::duplicate_field("scores"));
4067                            }
4068                            scores__ = Some(map_.next_value()?);
4069                        }
4070                    }
4071                }
4072                Ok(GetCompactionScoreResponse {
4073                    compaction_group_id: compaction_group_id__.unwrap_or_default(),
4074                    scores: scores__.unwrap_or_default(),
4075                })
4076            }
4077        }
4078        deserializer.deserialize_struct("hummock.GetCompactionScoreResponse", FIELDS, GeneratedVisitor)
4079    }
4080}
4081impl serde::Serialize for get_compaction_score_response::PickerInfo {
4082    #[allow(deprecated)]
4083    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4084    where
4085        S: serde::Serializer,
4086    {
4087        use serde::ser::SerializeStruct;
4088        let mut len = 0;
4089        if self.score != 0 {
4090            len += 1;
4091        }
4092        if self.select_level != 0 {
4093            len += 1;
4094        }
4095        if self.target_level != 0 {
4096            len += 1;
4097        }
4098        if !self.picker_type.is_empty() {
4099            len += 1;
4100        }
4101        let mut struct_ser = serializer.serialize_struct("hummock.GetCompactionScoreResponse.PickerInfo", len)?;
4102        if self.score != 0 {
4103            #[allow(clippy::needless_borrow)]
4104            #[allow(clippy::needless_borrows_for_generic_args)]
4105            struct_ser.serialize_field("score", ToString::to_string(&self.score).as_str())?;
4106        }
4107        if self.select_level != 0 {
4108            #[allow(clippy::needless_borrow)]
4109            #[allow(clippy::needless_borrows_for_generic_args)]
4110            struct_ser.serialize_field("selectLevel", ToString::to_string(&self.select_level).as_str())?;
4111        }
4112        if self.target_level != 0 {
4113            #[allow(clippy::needless_borrow)]
4114            #[allow(clippy::needless_borrows_for_generic_args)]
4115            struct_ser.serialize_field("targetLevel", ToString::to_string(&self.target_level).as_str())?;
4116        }
4117        if !self.picker_type.is_empty() {
4118            struct_ser.serialize_field("pickerType", &self.picker_type)?;
4119        }
4120        struct_ser.end()
4121    }
4122}
4123impl<'de> serde::Deserialize<'de> for get_compaction_score_response::PickerInfo {
4124    #[allow(deprecated)]
4125    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4126    where
4127        D: serde::Deserializer<'de>,
4128    {
4129        const FIELDS: &[&str] = &[
4130            "score",
4131            "select_level",
4132            "selectLevel",
4133            "target_level",
4134            "targetLevel",
4135            "picker_type",
4136            "pickerType",
4137        ];
4138
4139        #[allow(clippy::enum_variant_names)]
4140        enum GeneratedField {
4141            Score,
4142            SelectLevel,
4143            TargetLevel,
4144            PickerType,
4145        }
4146        impl<'de> serde::Deserialize<'de> for GeneratedField {
4147            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4148            where
4149                D: serde::Deserializer<'de>,
4150            {
4151                struct GeneratedVisitor;
4152
4153                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4154                    type Value = GeneratedField;
4155
4156                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4157                        write!(formatter, "expected one of: {:?}", &FIELDS)
4158                    }
4159
4160                    #[allow(unused_variables)]
4161                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4162                    where
4163                        E: serde::de::Error,
4164                    {
4165                        match value {
4166                            "score" => Ok(GeneratedField::Score),
4167                            "selectLevel" | "select_level" => Ok(GeneratedField::SelectLevel),
4168                            "targetLevel" | "target_level" => Ok(GeneratedField::TargetLevel),
4169                            "pickerType" | "picker_type" => Ok(GeneratedField::PickerType),
4170                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4171                        }
4172                    }
4173                }
4174                deserializer.deserialize_identifier(GeneratedVisitor)
4175            }
4176        }
4177        struct GeneratedVisitor;
4178        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4179            type Value = get_compaction_score_response::PickerInfo;
4180
4181            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4182                formatter.write_str("struct hummock.GetCompactionScoreResponse.PickerInfo")
4183            }
4184
4185            fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_compaction_score_response::PickerInfo, V::Error>
4186                where
4187                    V: serde::de::MapAccess<'de>,
4188            {
4189                let mut score__ = None;
4190                let mut select_level__ = None;
4191                let mut target_level__ = None;
4192                let mut picker_type__ = None;
4193                while let Some(k) = map_.next_key()? {
4194                    match k {
4195                        GeneratedField::Score => {
4196                            if score__.is_some() {
4197                                return Err(serde::de::Error::duplicate_field("score"));
4198                            }
4199                            score__ = 
4200                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4201                            ;
4202                        }
4203                        GeneratedField::SelectLevel => {
4204                            if select_level__.is_some() {
4205                                return Err(serde::de::Error::duplicate_field("selectLevel"));
4206                            }
4207                            select_level__ = 
4208                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4209                            ;
4210                        }
4211                        GeneratedField::TargetLevel => {
4212                            if target_level__.is_some() {
4213                                return Err(serde::de::Error::duplicate_field("targetLevel"));
4214                            }
4215                            target_level__ = 
4216                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4217                            ;
4218                        }
4219                        GeneratedField::PickerType => {
4220                            if picker_type__.is_some() {
4221                                return Err(serde::de::Error::duplicate_field("pickerType"));
4222                            }
4223                            picker_type__ = Some(map_.next_value()?);
4224                        }
4225                    }
4226                }
4227                Ok(get_compaction_score_response::PickerInfo {
4228                    score: score__.unwrap_or_default(),
4229                    select_level: select_level__.unwrap_or_default(),
4230                    target_level: target_level__.unwrap_or_default(),
4231                    picker_type: picker_type__.unwrap_or_default(),
4232                })
4233            }
4234        }
4235        deserializer.deserialize_struct("hummock.GetCompactionScoreResponse.PickerInfo", FIELDS, GeneratedVisitor)
4236    }
4237}
4238impl serde::Serialize for GetCurrentVersionRequest {
4239    #[allow(deprecated)]
4240    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4241    where
4242        S: serde::Serializer,
4243    {
4244        use serde::ser::SerializeStruct;
4245        let len = 0;
4246        let struct_ser = serializer.serialize_struct("hummock.GetCurrentVersionRequest", len)?;
4247        struct_ser.end()
4248    }
4249}
4250impl<'de> serde::Deserialize<'de> for GetCurrentVersionRequest {
4251    #[allow(deprecated)]
4252    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4253    where
4254        D: serde::Deserializer<'de>,
4255    {
4256        const FIELDS: &[&str] = &[
4257        ];
4258
4259        #[allow(clippy::enum_variant_names)]
4260        enum GeneratedField {
4261        }
4262        impl<'de> serde::Deserialize<'de> for GeneratedField {
4263            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4264            where
4265                D: serde::Deserializer<'de>,
4266            {
4267                struct GeneratedVisitor;
4268
4269                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4270                    type Value = GeneratedField;
4271
4272                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4273                        write!(formatter, "expected one of: {:?}", &FIELDS)
4274                    }
4275
4276                    #[allow(unused_variables)]
4277                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4278                    where
4279                        E: serde::de::Error,
4280                    {
4281                            Err(serde::de::Error::unknown_field(value, FIELDS))
4282                    }
4283                }
4284                deserializer.deserialize_identifier(GeneratedVisitor)
4285            }
4286        }
4287        struct GeneratedVisitor;
4288        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4289            type Value = GetCurrentVersionRequest;
4290
4291            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4292                formatter.write_str("struct hummock.GetCurrentVersionRequest")
4293            }
4294
4295            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCurrentVersionRequest, V::Error>
4296                where
4297                    V: serde::de::MapAccess<'de>,
4298            {
4299                while map_.next_key::<GeneratedField>()?.is_some() {
4300                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
4301                }
4302                Ok(GetCurrentVersionRequest {
4303                })
4304            }
4305        }
4306        deserializer.deserialize_struct("hummock.GetCurrentVersionRequest", FIELDS, GeneratedVisitor)
4307    }
4308}
4309impl serde::Serialize for GetCurrentVersionResponse {
4310    #[allow(deprecated)]
4311    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4312    where
4313        S: serde::Serializer,
4314    {
4315        use serde::ser::SerializeStruct;
4316        let mut len = 0;
4317        if self.status.is_some() {
4318            len += 1;
4319        }
4320        if self.current_version.is_some() {
4321            len += 1;
4322        }
4323        let mut struct_ser = serializer.serialize_struct("hummock.GetCurrentVersionResponse", len)?;
4324        if let Some(v) = self.status.as_ref() {
4325            struct_ser.serialize_field("status", v)?;
4326        }
4327        if let Some(v) = self.current_version.as_ref() {
4328            struct_ser.serialize_field("currentVersion", v)?;
4329        }
4330        struct_ser.end()
4331    }
4332}
4333impl<'de> serde::Deserialize<'de> for GetCurrentVersionResponse {
4334    #[allow(deprecated)]
4335    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4336    where
4337        D: serde::Deserializer<'de>,
4338    {
4339        const FIELDS: &[&str] = &[
4340            "status",
4341            "current_version",
4342            "currentVersion",
4343        ];
4344
4345        #[allow(clippy::enum_variant_names)]
4346        enum GeneratedField {
4347            Status,
4348            CurrentVersion,
4349        }
4350        impl<'de> serde::Deserialize<'de> for GeneratedField {
4351            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4352            where
4353                D: serde::Deserializer<'de>,
4354            {
4355                struct GeneratedVisitor;
4356
4357                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4358                    type Value = GeneratedField;
4359
4360                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4361                        write!(formatter, "expected one of: {:?}", &FIELDS)
4362                    }
4363
4364                    #[allow(unused_variables)]
4365                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4366                    where
4367                        E: serde::de::Error,
4368                    {
4369                        match value {
4370                            "status" => Ok(GeneratedField::Status),
4371                            "currentVersion" | "current_version" => Ok(GeneratedField::CurrentVersion),
4372                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4373                        }
4374                    }
4375                }
4376                deserializer.deserialize_identifier(GeneratedVisitor)
4377            }
4378        }
4379        struct GeneratedVisitor;
4380        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4381            type Value = GetCurrentVersionResponse;
4382
4383            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4384                formatter.write_str("struct hummock.GetCurrentVersionResponse")
4385            }
4386
4387            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetCurrentVersionResponse, V::Error>
4388                where
4389                    V: serde::de::MapAccess<'de>,
4390            {
4391                let mut status__ = None;
4392                let mut current_version__ = None;
4393                while let Some(k) = map_.next_key()? {
4394                    match k {
4395                        GeneratedField::Status => {
4396                            if status__.is_some() {
4397                                return Err(serde::de::Error::duplicate_field("status"));
4398                            }
4399                            status__ = map_.next_value()?;
4400                        }
4401                        GeneratedField::CurrentVersion => {
4402                            if current_version__.is_some() {
4403                                return Err(serde::de::Error::duplicate_field("currentVersion"));
4404                            }
4405                            current_version__ = map_.next_value()?;
4406                        }
4407                    }
4408                }
4409                Ok(GetCurrentVersionResponse {
4410                    status: status__,
4411                    current_version: current_version__,
4412                })
4413            }
4414        }
4415        deserializer.deserialize_struct("hummock.GetCurrentVersionResponse", FIELDS, GeneratedVisitor)
4416    }
4417}
4418impl serde::Serialize for GetNewObjectIdsRequest {
4419    #[allow(deprecated)]
4420    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4421    where
4422        S: serde::Serializer,
4423    {
4424        use serde::ser::SerializeStruct;
4425        let mut len = 0;
4426        if self.number != 0 {
4427            len += 1;
4428        }
4429        let mut struct_ser = serializer.serialize_struct("hummock.GetNewObjectIdsRequest", len)?;
4430        if self.number != 0 {
4431            struct_ser.serialize_field("number", &self.number)?;
4432        }
4433        struct_ser.end()
4434    }
4435}
4436impl<'de> serde::Deserialize<'de> for GetNewObjectIdsRequest {
4437    #[allow(deprecated)]
4438    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4439    where
4440        D: serde::Deserializer<'de>,
4441    {
4442        const FIELDS: &[&str] = &[
4443            "number",
4444        ];
4445
4446        #[allow(clippy::enum_variant_names)]
4447        enum GeneratedField {
4448            Number,
4449        }
4450        impl<'de> serde::Deserialize<'de> for GeneratedField {
4451            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4452            where
4453                D: serde::Deserializer<'de>,
4454            {
4455                struct GeneratedVisitor;
4456
4457                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4458                    type Value = GeneratedField;
4459
4460                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4461                        write!(formatter, "expected one of: {:?}", &FIELDS)
4462                    }
4463
4464                    #[allow(unused_variables)]
4465                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4466                    where
4467                        E: serde::de::Error,
4468                    {
4469                        match value {
4470                            "number" => Ok(GeneratedField::Number),
4471                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4472                        }
4473                    }
4474                }
4475                deserializer.deserialize_identifier(GeneratedVisitor)
4476            }
4477        }
4478        struct GeneratedVisitor;
4479        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4480            type Value = GetNewObjectIdsRequest;
4481
4482            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4483                formatter.write_str("struct hummock.GetNewObjectIdsRequest")
4484            }
4485
4486            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetNewObjectIdsRequest, V::Error>
4487                where
4488                    V: serde::de::MapAccess<'de>,
4489            {
4490                let mut number__ = None;
4491                while let Some(k) = map_.next_key()? {
4492                    match k {
4493                        GeneratedField::Number => {
4494                            if number__.is_some() {
4495                                return Err(serde::de::Error::duplicate_field("number"));
4496                            }
4497                            number__ = 
4498                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4499                            ;
4500                        }
4501                    }
4502                }
4503                Ok(GetNewObjectIdsRequest {
4504                    number: number__.unwrap_or_default(),
4505                })
4506            }
4507        }
4508        deserializer.deserialize_struct("hummock.GetNewObjectIdsRequest", FIELDS, GeneratedVisitor)
4509    }
4510}
4511impl serde::Serialize for GetNewObjectIdsResponse {
4512    #[allow(deprecated)]
4513    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4514    where
4515        S: serde::Serializer,
4516    {
4517        use serde::ser::SerializeStruct;
4518        let mut len = 0;
4519        if self.status.is_some() {
4520            len += 1;
4521        }
4522        if self.start_id != 0 {
4523            len += 1;
4524        }
4525        if self.end_id != 0 {
4526            len += 1;
4527        }
4528        let mut struct_ser = serializer.serialize_struct("hummock.GetNewObjectIdsResponse", len)?;
4529        if let Some(v) = self.status.as_ref() {
4530            struct_ser.serialize_field("status", v)?;
4531        }
4532        if self.start_id != 0 {
4533            #[allow(clippy::needless_borrow)]
4534            #[allow(clippy::needless_borrows_for_generic_args)]
4535            struct_ser.serialize_field("startId", ToString::to_string(&self.start_id).as_str())?;
4536        }
4537        if self.end_id != 0 {
4538            #[allow(clippy::needless_borrow)]
4539            #[allow(clippy::needless_borrows_for_generic_args)]
4540            struct_ser.serialize_field("endId", ToString::to_string(&self.end_id).as_str())?;
4541        }
4542        struct_ser.end()
4543    }
4544}
4545impl<'de> serde::Deserialize<'de> for GetNewObjectIdsResponse {
4546    #[allow(deprecated)]
4547    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4548    where
4549        D: serde::Deserializer<'de>,
4550    {
4551        const FIELDS: &[&str] = &[
4552            "status",
4553            "start_id",
4554            "startId",
4555            "end_id",
4556            "endId",
4557        ];
4558
4559        #[allow(clippy::enum_variant_names)]
4560        enum GeneratedField {
4561            Status,
4562            StartId,
4563            EndId,
4564        }
4565        impl<'de> serde::Deserialize<'de> for GeneratedField {
4566            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4567            where
4568                D: serde::Deserializer<'de>,
4569            {
4570                struct GeneratedVisitor;
4571
4572                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4573                    type Value = GeneratedField;
4574
4575                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4576                        write!(formatter, "expected one of: {:?}", &FIELDS)
4577                    }
4578
4579                    #[allow(unused_variables)]
4580                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4581                    where
4582                        E: serde::de::Error,
4583                    {
4584                        match value {
4585                            "status" => Ok(GeneratedField::Status),
4586                            "startId" | "start_id" => Ok(GeneratedField::StartId),
4587                            "endId" | "end_id" => Ok(GeneratedField::EndId),
4588                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4589                        }
4590                    }
4591                }
4592                deserializer.deserialize_identifier(GeneratedVisitor)
4593            }
4594        }
4595        struct GeneratedVisitor;
4596        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4597            type Value = GetNewObjectIdsResponse;
4598
4599            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4600                formatter.write_str("struct hummock.GetNewObjectIdsResponse")
4601            }
4602
4603            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetNewObjectIdsResponse, V::Error>
4604                where
4605                    V: serde::de::MapAccess<'de>,
4606            {
4607                let mut status__ = None;
4608                let mut start_id__ = None;
4609                let mut end_id__ = None;
4610                while let Some(k) = map_.next_key()? {
4611                    match k {
4612                        GeneratedField::Status => {
4613                            if status__.is_some() {
4614                                return Err(serde::de::Error::duplicate_field("status"));
4615                            }
4616                            status__ = map_.next_value()?;
4617                        }
4618                        GeneratedField::StartId => {
4619                            if start_id__.is_some() {
4620                                return Err(serde::de::Error::duplicate_field("startId"));
4621                            }
4622                            start_id__ = 
4623                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4624                            ;
4625                        }
4626                        GeneratedField::EndId => {
4627                            if end_id__.is_some() {
4628                                return Err(serde::de::Error::duplicate_field("endId"));
4629                            }
4630                            end_id__ = 
4631                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4632                            ;
4633                        }
4634                    }
4635                }
4636                Ok(GetNewObjectIdsResponse {
4637                    status: status__,
4638                    start_id: start_id__.unwrap_or_default(),
4639                    end_id: end_id__.unwrap_or_default(),
4640                })
4641            }
4642        }
4643        deserializer.deserialize_struct("hummock.GetNewObjectIdsResponse", FIELDS, GeneratedVisitor)
4644    }
4645}
4646impl serde::Serialize for GetVersionByEpochRequest {
4647    #[allow(deprecated)]
4648    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4649    where
4650        S: serde::Serializer,
4651    {
4652        use serde::ser::SerializeStruct;
4653        let mut len = 0;
4654        if self.epoch != 0 {
4655            len += 1;
4656        }
4657        if self.table_id != 0 {
4658            len += 1;
4659        }
4660        let mut struct_ser = serializer.serialize_struct("hummock.GetVersionByEpochRequest", len)?;
4661        if self.epoch != 0 {
4662            #[allow(clippy::needless_borrow)]
4663            #[allow(clippy::needless_borrows_for_generic_args)]
4664            struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
4665        }
4666        if self.table_id != 0 {
4667            struct_ser.serialize_field("tableId", &self.table_id)?;
4668        }
4669        struct_ser.end()
4670    }
4671}
4672impl<'de> serde::Deserialize<'de> for GetVersionByEpochRequest {
4673    #[allow(deprecated)]
4674    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4675    where
4676        D: serde::Deserializer<'de>,
4677    {
4678        const FIELDS: &[&str] = &[
4679            "epoch",
4680            "table_id",
4681            "tableId",
4682        ];
4683
4684        #[allow(clippy::enum_variant_names)]
4685        enum GeneratedField {
4686            Epoch,
4687            TableId,
4688        }
4689        impl<'de> serde::Deserialize<'de> for GeneratedField {
4690            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4691            where
4692                D: serde::Deserializer<'de>,
4693            {
4694                struct GeneratedVisitor;
4695
4696                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4697                    type Value = GeneratedField;
4698
4699                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4700                        write!(formatter, "expected one of: {:?}", &FIELDS)
4701                    }
4702
4703                    #[allow(unused_variables)]
4704                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4705                    where
4706                        E: serde::de::Error,
4707                    {
4708                        match value {
4709                            "epoch" => Ok(GeneratedField::Epoch),
4710                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
4711                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4712                        }
4713                    }
4714                }
4715                deserializer.deserialize_identifier(GeneratedVisitor)
4716            }
4717        }
4718        struct GeneratedVisitor;
4719        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4720            type Value = GetVersionByEpochRequest;
4721
4722            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4723                formatter.write_str("struct hummock.GetVersionByEpochRequest")
4724            }
4725
4726            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetVersionByEpochRequest, V::Error>
4727                where
4728                    V: serde::de::MapAccess<'de>,
4729            {
4730                let mut epoch__ = None;
4731                let mut table_id__ = None;
4732                while let Some(k) = map_.next_key()? {
4733                    match k {
4734                        GeneratedField::Epoch => {
4735                            if epoch__.is_some() {
4736                                return Err(serde::de::Error::duplicate_field("epoch"));
4737                            }
4738                            epoch__ = 
4739                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4740                            ;
4741                        }
4742                        GeneratedField::TableId => {
4743                            if table_id__.is_some() {
4744                                return Err(serde::de::Error::duplicate_field("tableId"));
4745                            }
4746                            table_id__ = 
4747                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4748                            ;
4749                        }
4750                    }
4751                }
4752                Ok(GetVersionByEpochRequest {
4753                    epoch: epoch__.unwrap_or_default(),
4754                    table_id: table_id__.unwrap_or_default(),
4755                })
4756            }
4757        }
4758        deserializer.deserialize_struct("hummock.GetVersionByEpochRequest", FIELDS, GeneratedVisitor)
4759    }
4760}
4761impl serde::Serialize for GetVersionByEpochResponse {
4762    #[allow(deprecated)]
4763    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4764    where
4765        S: serde::Serializer,
4766    {
4767        use serde::ser::SerializeStruct;
4768        let mut len = 0;
4769        if self.version.is_some() {
4770            len += 1;
4771        }
4772        let mut struct_ser = serializer.serialize_struct("hummock.GetVersionByEpochResponse", len)?;
4773        if let Some(v) = self.version.as_ref() {
4774            struct_ser.serialize_field("version", v)?;
4775        }
4776        struct_ser.end()
4777    }
4778}
4779impl<'de> serde::Deserialize<'de> for GetVersionByEpochResponse {
4780    #[allow(deprecated)]
4781    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4782    where
4783        D: serde::Deserializer<'de>,
4784    {
4785        const FIELDS: &[&str] = &[
4786            "version",
4787        ];
4788
4789        #[allow(clippy::enum_variant_names)]
4790        enum GeneratedField {
4791            Version,
4792        }
4793        impl<'de> serde::Deserialize<'de> for GeneratedField {
4794            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4795            where
4796                D: serde::Deserializer<'de>,
4797            {
4798                struct GeneratedVisitor;
4799
4800                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4801                    type Value = GeneratedField;
4802
4803                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4804                        write!(formatter, "expected one of: {:?}", &FIELDS)
4805                    }
4806
4807                    #[allow(unused_variables)]
4808                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4809                    where
4810                        E: serde::de::Error,
4811                    {
4812                        match value {
4813                            "version" => Ok(GeneratedField::Version),
4814                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4815                        }
4816                    }
4817                }
4818                deserializer.deserialize_identifier(GeneratedVisitor)
4819            }
4820        }
4821        struct GeneratedVisitor;
4822        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4823            type Value = GetVersionByEpochResponse;
4824
4825            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4826                formatter.write_str("struct hummock.GetVersionByEpochResponse")
4827            }
4828
4829            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetVersionByEpochResponse, V::Error>
4830                where
4831                    V: serde::de::MapAccess<'de>,
4832            {
4833                let mut version__ = None;
4834                while let Some(k) = map_.next_key()? {
4835                    match k {
4836                        GeneratedField::Version => {
4837                            if version__.is_some() {
4838                                return Err(serde::de::Error::duplicate_field("version"));
4839                            }
4840                            version__ = map_.next_value()?;
4841                        }
4842                    }
4843                }
4844                Ok(GetVersionByEpochResponse {
4845                    version: version__,
4846                })
4847            }
4848        }
4849        deserializer.deserialize_struct("hummock.GetVersionByEpochResponse", FIELDS, GeneratedVisitor)
4850    }
4851}
4852impl serde::Serialize for GroupConstruct {
4853    #[allow(deprecated)]
4854    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4855    where
4856        S: serde::Serializer,
4857    {
4858        use serde::ser::SerializeStruct;
4859        let mut len = 0;
4860        if self.group_config.is_some() {
4861            len += 1;
4862        }
4863        if self.parent_group_id != 0 {
4864            len += 1;
4865        }
4866        if !self.table_ids.is_empty() {
4867            len += 1;
4868        }
4869        if self.group_id != 0 {
4870            len += 1;
4871        }
4872        if self.new_sst_start_id != 0 {
4873            len += 1;
4874        }
4875        if self.version != 0 {
4876            len += 1;
4877        }
4878        if self.split_key.is_some() {
4879            len += 1;
4880        }
4881        let mut struct_ser = serializer.serialize_struct("hummock.GroupConstruct", len)?;
4882        if let Some(v) = self.group_config.as_ref() {
4883            struct_ser.serialize_field("groupConfig", v)?;
4884        }
4885        if self.parent_group_id != 0 {
4886            #[allow(clippy::needless_borrow)]
4887            #[allow(clippy::needless_borrows_for_generic_args)]
4888            struct_ser.serialize_field("parentGroupId", ToString::to_string(&self.parent_group_id).as_str())?;
4889        }
4890        if !self.table_ids.is_empty() {
4891            struct_ser.serialize_field("tableIds", &self.table_ids)?;
4892        }
4893        if self.group_id != 0 {
4894            #[allow(clippy::needless_borrow)]
4895            #[allow(clippy::needless_borrows_for_generic_args)]
4896            struct_ser.serialize_field("groupId", ToString::to_string(&self.group_id).as_str())?;
4897        }
4898        if self.new_sst_start_id != 0 {
4899            #[allow(clippy::needless_borrow)]
4900            #[allow(clippy::needless_borrows_for_generic_args)]
4901            struct_ser.serialize_field("newSstStartId", ToString::to_string(&self.new_sst_start_id).as_str())?;
4902        }
4903        if self.version != 0 {
4904            let v = CompatibilityVersion::try_from(self.version)
4905                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
4906            struct_ser.serialize_field("version", &v)?;
4907        }
4908        if let Some(v) = self.split_key.as_ref() {
4909            #[allow(clippy::needless_borrow)]
4910            #[allow(clippy::needless_borrows_for_generic_args)]
4911            struct_ser.serialize_field("splitKey", pbjson::private::base64::encode(&v).as_str())?;
4912        }
4913        struct_ser.end()
4914    }
4915}
4916impl<'de> serde::Deserialize<'de> for GroupConstruct {
4917    #[allow(deprecated)]
4918    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4919    where
4920        D: serde::Deserializer<'de>,
4921    {
4922        const FIELDS: &[&str] = &[
4923            "group_config",
4924            "groupConfig",
4925            "parent_group_id",
4926            "parentGroupId",
4927            "table_ids",
4928            "tableIds",
4929            "group_id",
4930            "groupId",
4931            "new_sst_start_id",
4932            "newSstStartId",
4933            "version",
4934            "split_key",
4935            "splitKey",
4936        ];
4937
4938        #[allow(clippy::enum_variant_names)]
4939        enum GeneratedField {
4940            GroupConfig,
4941            ParentGroupId,
4942            TableIds,
4943            GroupId,
4944            NewSstStartId,
4945            Version,
4946            SplitKey,
4947        }
4948        impl<'de> serde::Deserialize<'de> for GeneratedField {
4949            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4950            where
4951                D: serde::Deserializer<'de>,
4952            {
4953                struct GeneratedVisitor;
4954
4955                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4956                    type Value = GeneratedField;
4957
4958                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4959                        write!(formatter, "expected one of: {:?}", &FIELDS)
4960                    }
4961
4962                    #[allow(unused_variables)]
4963                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4964                    where
4965                        E: serde::de::Error,
4966                    {
4967                        match value {
4968                            "groupConfig" | "group_config" => Ok(GeneratedField::GroupConfig),
4969                            "parentGroupId" | "parent_group_id" => Ok(GeneratedField::ParentGroupId),
4970                            "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
4971                            "groupId" | "group_id" => Ok(GeneratedField::GroupId),
4972                            "newSstStartId" | "new_sst_start_id" => Ok(GeneratedField::NewSstStartId),
4973                            "version" => Ok(GeneratedField::Version),
4974                            "splitKey" | "split_key" => Ok(GeneratedField::SplitKey),
4975                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4976                        }
4977                    }
4978                }
4979                deserializer.deserialize_identifier(GeneratedVisitor)
4980            }
4981        }
4982        struct GeneratedVisitor;
4983        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4984            type Value = GroupConstruct;
4985
4986            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4987                formatter.write_str("struct hummock.GroupConstruct")
4988            }
4989
4990            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupConstruct, V::Error>
4991                where
4992                    V: serde::de::MapAccess<'de>,
4993            {
4994                let mut group_config__ = None;
4995                let mut parent_group_id__ = None;
4996                let mut table_ids__ = None;
4997                let mut group_id__ = None;
4998                let mut new_sst_start_id__ = None;
4999                let mut version__ = None;
5000                let mut split_key__ = None;
5001                while let Some(k) = map_.next_key()? {
5002                    match k {
5003                        GeneratedField::GroupConfig => {
5004                            if group_config__.is_some() {
5005                                return Err(serde::de::Error::duplicate_field("groupConfig"));
5006                            }
5007                            group_config__ = map_.next_value()?;
5008                        }
5009                        GeneratedField::ParentGroupId => {
5010                            if parent_group_id__.is_some() {
5011                                return Err(serde::de::Error::duplicate_field("parentGroupId"));
5012                            }
5013                            parent_group_id__ = 
5014                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5015                            ;
5016                        }
5017                        GeneratedField::TableIds => {
5018                            if table_ids__.is_some() {
5019                                return Err(serde::de::Error::duplicate_field("tableIds"));
5020                            }
5021                            table_ids__ = 
5022                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5023                                    .into_iter().map(|x| x.0).collect())
5024                            ;
5025                        }
5026                        GeneratedField::GroupId => {
5027                            if group_id__.is_some() {
5028                                return Err(serde::de::Error::duplicate_field("groupId"));
5029                            }
5030                            group_id__ = 
5031                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5032                            ;
5033                        }
5034                        GeneratedField::NewSstStartId => {
5035                            if new_sst_start_id__.is_some() {
5036                                return Err(serde::de::Error::duplicate_field("newSstStartId"));
5037                            }
5038                            new_sst_start_id__ = 
5039                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5040                            ;
5041                        }
5042                        GeneratedField::Version => {
5043                            if version__.is_some() {
5044                                return Err(serde::de::Error::duplicate_field("version"));
5045                            }
5046                            version__ = Some(map_.next_value::<CompatibilityVersion>()? as i32);
5047                        }
5048                        GeneratedField::SplitKey => {
5049                            if split_key__.is_some() {
5050                                return Err(serde::de::Error::duplicate_field("splitKey"));
5051                            }
5052                            split_key__ = 
5053                                map_.next_value::<::std::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| x.0)
5054                            ;
5055                        }
5056                    }
5057                }
5058                Ok(GroupConstruct {
5059                    group_config: group_config__,
5060                    parent_group_id: parent_group_id__.unwrap_or_default(),
5061                    table_ids: table_ids__.unwrap_or_default(),
5062                    group_id: group_id__.unwrap_or_default(),
5063                    new_sst_start_id: new_sst_start_id__.unwrap_or_default(),
5064                    version: version__.unwrap_or_default(),
5065                    split_key: split_key__,
5066                })
5067            }
5068        }
5069        deserializer.deserialize_struct("hummock.GroupConstruct", FIELDS, GeneratedVisitor)
5070    }
5071}
5072impl serde::Serialize for GroupDelta {
5073    #[allow(deprecated)]
5074    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5075    where
5076        S: serde::Serializer,
5077    {
5078        use serde::ser::SerializeStruct;
5079        let mut len = 0;
5080        if self.delta_type.is_some() {
5081            len += 1;
5082        }
5083        let mut struct_ser = serializer.serialize_struct("hummock.GroupDelta", len)?;
5084        if let Some(v) = self.delta_type.as_ref() {
5085            match v {
5086                group_delta::DeltaType::IntraLevel(v) => {
5087                    struct_ser.serialize_field("intraLevel", v)?;
5088                }
5089                group_delta::DeltaType::GroupConstruct(v) => {
5090                    struct_ser.serialize_field("groupConstruct", v)?;
5091                }
5092                group_delta::DeltaType::GroupDestroy(v) => {
5093                    struct_ser.serialize_field("groupDestroy", v)?;
5094                }
5095                group_delta::DeltaType::GroupMerge(v) => {
5096                    struct_ser.serialize_field("groupMerge", v)?;
5097                }
5098                group_delta::DeltaType::NewL0SubLevel(v) => {
5099                    struct_ser.serialize_field("newL0SubLevel", v)?;
5100                }
5101            }
5102        }
5103        struct_ser.end()
5104    }
5105}
5106impl<'de> serde::Deserialize<'de> for GroupDelta {
5107    #[allow(deprecated)]
5108    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5109    where
5110        D: serde::Deserializer<'de>,
5111    {
5112        const FIELDS: &[&str] = &[
5113            "intra_level",
5114            "intraLevel",
5115            "group_construct",
5116            "groupConstruct",
5117            "group_destroy",
5118            "groupDestroy",
5119            "group_merge",
5120            "groupMerge",
5121            "new_l0_sub_level",
5122            "newL0SubLevel",
5123        ];
5124
5125        #[allow(clippy::enum_variant_names)]
5126        enum GeneratedField {
5127            IntraLevel,
5128            GroupConstruct,
5129            GroupDestroy,
5130            GroupMerge,
5131            NewL0SubLevel,
5132        }
5133        impl<'de> serde::Deserialize<'de> for GeneratedField {
5134            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5135            where
5136                D: serde::Deserializer<'de>,
5137            {
5138                struct GeneratedVisitor;
5139
5140                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5141                    type Value = GeneratedField;
5142
5143                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5144                        write!(formatter, "expected one of: {:?}", &FIELDS)
5145                    }
5146
5147                    #[allow(unused_variables)]
5148                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5149                    where
5150                        E: serde::de::Error,
5151                    {
5152                        match value {
5153                            "intraLevel" | "intra_level" => Ok(GeneratedField::IntraLevel),
5154                            "groupConstruct" | "group_construct" => Ok(GeneratedField::GroupConstruct),
5155                            "groupDestroy" | "group_destroy" => Ok(GeneratedField::GroupDestroy),
5156                            "groupMerge" | "group_merge" => Ok(GeneratedField::GroupMerge),
5157                            "newL0SubLevel" | "new_l0_sub_level" => Ok(GeneratedField::NewL0SubLevel),
5158                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5159                        }
5160                    }
5161                }
5162                deserializer.deserialize_identifier(GeneratedVisitor)
5163            }
5164        }
5165        struct GeneratedVisitor;
5166        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5167            type Value = GroupDelta;
5168
5169            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5170                formatter.write_str("struct hummock.GroupDelta")
5171            }
5172
5173            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupDelta, V::Error>
5174                where
5175                    V: serde::de::MapAccess<'de>,
5176            {
5177                let mut delta_type__ = None;
5178                while let Some(k) = map_.next_key()? {
5179                    match k {
5180                        GeneratedField::IntraLevel => {
5181                            if delta_type__.is_some() {
5182                                return Err(serde::de::Error::duplicate_field("intraLevel"));
5183                            }
5184                            delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::IntraLevel)
5185;
5186                        }
5187                        GeneratedField::GroupConstruct => {
5188                            if delta_type__.is_some() {
5189                                return Err(serde::de::Error::duplicate_field("groupConstruct"));
5190                            }
5191                            delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::GroupConstruct)
5192;
5193                        }
5194                        GeneratedField::GroupDestroy => {
5195                            if delta_type__.is_some() {
5196                                return Err(serde::de::Error::duplicate_field("groupDestroy"));
5197                            }
5198                            delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::GroupDestroy)
5199;
5200                        }
5201                        GeneratedField::GroupMerge => {
5202                            if delta_type__.is_some() {
5203                                return Err(serde::de::Error::duplicate_field("groupMerge"));
5204                            }
5205                            delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::GroupMerge)
5206;
5207                        }
5208                        GeneratedField::NewL0SubLevel => {
5209                            if delta_type__.is_some() {
5210                                return Err(serde::de::Error::duplicate_field("newL0SubLevel"));
5211                            }
5212                            delta_type__ = map_.next_value::<::std::option::Option<_>>()?.map(group_delta::DeltaType::NewL0SubLevel)
5213;
5214                        }
5215                    }
5216                }
5217                Ok(GroupDelta {
5218                    delta_type: delta_type__,
5219                })
5220            }
5221        }
5222        deserializer.deserialize_struct("hummock.GroupDelta", FIELDS, GeneratedVisitor)
5223    }
5224}
5225impl serde::Serialize for GroupDestroy {
5226    #[allow(deprecated)]
5227    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5228    where
5229        S: serde::Serializer,
5230    {
5231        use serde::ser::SerializeStruct;
5232        let len = 0;
5233        let struct_ser = serializer.serialize_struct("hummock.GroupDestroy", len)?;
5234        struct_ser.end()
5235    }
5236}
5237impl<'de> serde::Deserialize<'de> for GroupDestroy {
5238    #[allow(deprecated)]
5239    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5240    where
5241        D: serde::Deserializer<'de>,
5242    {
5243        const FIELDS: &[&str] = &[
5244        ];
5245
5246        #[allow(clippy::enum_variant_names)]
5247        enum GeneratedField {
5248        }
5249        impl<'de> serde::Deserialize<'de> for GeneratedField {
5250            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5251            where
5252                D: serde::Deserializer<'de>,
5253            {
5254                struct GeneratedVisitor;
5255
5256                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5257                    type Value = GeneratedField;
5258
5259                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5260                        write!(formatter, "expected one of: {:?}", &FIELDS)
5261                    }
5262
5263                    #[allow(unused_variables)]
5264                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5265                    where
5266                        E: serde::de::Error,
5267                    {
5268                            Err(serde::de::Error::unknown_field(value, FIELDS))
5269                    }
5270                }
5271                deserializer.deserialize_identifier(GeneratedVisitor)
5272            }
5273        }
5274        struct GeneratedVisitor;
5275        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5276            type Value = GroupDestroy;
5277
5278            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5279                formatter.write_str("struct hummock.GroupDestroy")
5280            }
5281
5282            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupDestroy, V::Error>
5283                where
5284                    V: serde::de::MapAccess<'de>,
5285            {
5286                while map_.next_key::<GeneratedField>()?.is_some() {
5287                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
5288                }
5289                Ok(GroupDestroy {
5290                })
5291            }
5292        }
5293        deserializer.deserialize_struct("hummock.GroupDestroy", FIELDS, GeneratedVisitor)
5294    }
5295}
5296impl serde::Serialize for GroupMerge {
5297    #[allow(deprecated)]
5298    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5299    where
5300        S: serde::Serializer,
5301    {
5302        use serde::ser::SerializeStruct;
5303        let mut len = 0;
5304        if self.left_group_id != 0 {
5305            len += 1;
5306        }
5307        if self.right_group_id != 0 {
5308            len += 1;
5309        }
5310        let mut struct_ser = serializer.serialize_struct("hummock.GroupMerge", len)?;
5311        if self.left_group_id != 0 {
5312            #[allow(clippy::needless_borrow)]
5313            #[allow(clippy::needless_borrows_for_generic_args)]
5314            struct_ser.serialize_field("leftGroupId", ToString::to_string(&self.left_group_id).as_str())?;
5315        }
5316        if self.right_group_id != 0 {
5317            #[allow(clippy::needless_borrow)]
5318            #[allow(clippy::needless_borrows_for_generic_args)]
5319            struct_ser.serialize_field("rightGroupId", ToString::to_string(&self.right_group_id).as_str())?;
5320        }
5321        struct_ser.end()
5322    }
5323}
5324impl<'de> serde::Deserialize<'de> for GroupMerge {
5325    #[allow(deprecated)]
5326    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5327    where
5328        D: serde::Deserializer<'de>,
5329    {
5330        const FIELDS: &[&str] = &[
5331            "left_group_id",
5332            "leftGroupId",
5333            "right_group_id",
5334            "rightGroupId",
5335        ];
5336
5337        #[allow(clippy::enum_variant_names)]
5338        enum GeneratedField {
5339            LeftGroupId,
5340            RightGroupId,
5341        }
5342        impl<'de> serde::Deserialize<'de> for GeneratedField {
5343            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5344            where
5345                D: serde::Deserializer<'de>,
5346            {
5347                struct GeneratedVisitor;
5348
5349                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5350                    type Value = GeneratedField;
5351
5352                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5353                        write!(formatter, "expected one of: {:?}", &FIELDS)
5354                    }
5355
5356                    #[allow(unused_variables)]
5357                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5358                    where
5359                        E: serde::de::Error,
5360                    {
5361                        match value {
5362                            "leftGroupId" | "left_group_id" => Ok(GeneratedField::LeftGroupId),
5363                            "rightGroupId" | "right_group_id" => Ok(GeneratedField::RightGroupId),
5364                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5365                        }
5366                    }
5367                }
5368                deserializer.deserialize_identifier(GeneratedVisitor)
5369            }
5370        }
5371        struct GeneratedVisitor;
5372        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5373            type Value = GroupMerge;
5374
5375            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5376                formatter.write_str("struct hummock.GroupMerge")
5377            }
5378
5379            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupMerge, V::Error>
5380                where
5381                    V: serde::de::MapAccess<'de>,
5382            {
5383                let mut left_group_id__ = None;
5384                let mut right_group_id__ = None;
5385                while let Some(k) = map_.next_key()? {
5386                    match k {
5387                        GeneratedField::LeftGroupId => {
5388                            if left_group_id__.is_some() {
5389                                return Err(serde::de::Error::duplicate_field("leftGroupId"));
5390                            }
5391                            left_group_id__ = 
5392                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5393                            ;
5394                        }
5395                        GeneratedField::RightGroupId => {
5396                            if right_group_id__.is_some() {
5397                                return Err(serde::de::Error::duplicate_field("rightGroupId"));
5398                            }
5399                            right_group_id__ = 
5400                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5401                            ;
5402                        }
5403                    }
5404                }
5405                Ok(GroupMerge {
5406                    left_group_id: left_group_id__.unwrap_or_default(),
5407                    right_group_id: right_group_id__.unwrap_or_default(),
5408                })
5409            }
5410        }
5411        deserializer.deserialize_struct("hummock.GroupMerge", FIELDS, GeneratedVisitor)
5412    }
5413}
5414impl serde::Serialize for HummockPinnedSnapshot {
5415    #[allow(deprecated)]
5416    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5417    where
5418        S: serde::Serializer,
5419    {
5420        use serde::ser::SerializeStruct;
5421        let mut len = 0;
5422        if self.context_id != 0 {
5423            len += 1;
5424        }
5425        if self.minimal_pinned_snapshot != 0 {
5426            len += 1;
5427        }
5428        let mut struct_ser = serializer.serialize_struct("hummock.HummockPinnedSnapshot", len)?;
5429        if self.context_id != 0 {
5430            struct_ser.serialize_field("contextId", &self.context_id)?;
5431        }
5432        if self.minimal_pinned_snapshot != 0 {
5433            #[allow(clippy::needless_borrow)]
5434            #[allow(clippy::needless_borrows_for_generic_args)]
5435            struct_ser.serialize_field("minimalPinnedSnapshot", ToString::to_string(&self.minimal_pinned_snapshot).as_str())?;
5436        }
5437        struct_ser.end()
5438    }
5439}
5440impl<'de> serde::Deserialize<'de> for HummockPinnedSnapshot {
5441    #[allow(deprecated)]
5442    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5443    where
5444        D: serde::Deserializer<'de>,
5445    {
5446        const FIELDS: &[&str] = &[
5447            "context_id",
5448            "contextId",
5449            "minimal_pinned_snapshot",
5450            "minimalPinnedSnapshot",
5451        ];
5452
5453        #[allow(clippy::enum_variant_names)]
5454        enum GeneratedField {
5455            ContextId,
5456            MinimalPinnedSnapshot,
5457        }
5458        impl<'de> serde::Deserialize<'de> for GeneratedField {
5459            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5460            where
5461                D: serde::Deserializer<'de>,
5462            {
5463                struct GeneratedVisitor;
5464
5465                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5466                    type Value = GeneratedField;
5467
5468                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5469                        write!(formatter, "expected one of: {:?}", &FIELDS)
5470                    }
5471
5472                    #[allow(unused_variables)]
5473                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5474                    where
5475                        E: serde::de::Error,
5476                    {
5477                        match value {
5478                            "contextId" | "context_id" => Ok(GeneratedField::ContextId),
5479                            "minimalPinnedSnapshot" | "minimal_pinned_snapshot" => Ok(GeneratedField::MinimalPinnedSnapshot),
5480                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5481                        }
5482                    }
5483                }
5484                deserializer.deserialize_identifier(GeneratedVisitor)
5485            }
5486        }
5487        struct GeneratedVisitor;
5488        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5489            type Value = HummockPinnedSnapshot;
5490
5491            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5492                formatter.write_str("struct hummock.HummockPinnedSnapshot")
5493            }
5494
5495            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockPinnedSnapshot, V::Error>
5496                where
5497                    V: serde::de::MapAccess<'de>,
5498            {
5499                let mut context_id__ = None;
5500                let mut minimal_pinned_snapshot__ = None;
5501                while let Some(k) = map_.next_key()? {
5502                    match k {
5503                        GeneratedField::ContextId => {
5504                            if context_id__.is_some() {
5505                                return Err(serde::de::Error::duplicate_field("contextId"));
5506                            }
5507                            context_id__ = 
5508                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5509                            ;
5510                        }
5511                        GeneratedField::MinimalPinnedSnapshot => {
5512                            if minimal_pinned_snapshot__.is_some() {
5513                                return Err(serde::de::Error::duplicate_field("minimalPinnedSnapshot"));
5514                            }
5515                            minimal_pinned_snapshot__ = 
5516                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5517                            ;
5518                        }
5519                    }
5520                }
5521                Ok(HummockPinnedSnapshot {
5522                    context_id: context_id__.unwrap_or_default(),
5523                    minimal_pinned_snapshot: minimal_pinned_snapshot__.unwrap_or_default(),
5524                })
5525            }
5526        }
5527        deserializer.deserialize_struct("hummock.HummockPinnedSnapshot", FIELDS, GeneratedVisitor)
5528    }
5529}
5530impl serde::Serialize for HummockPinnedVersion {
5531    #[allow(deprecated)]
5532    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5533    where
5534        S: serde::Serializer,
5535    {
5536        use serde::ser::SerializeStruct;
5537        let mut len = 0;
5538        if self.context_id != 0 {
5539            len += 1;
5540        }
5541        if self.min_pinned_id != 0 {
5542            len += 1;
5543        }
5544        let mut struct_ser = serializer.serialize_struct("hummock.HummockPinnedVersion", len)?;
5545        if self.context_id != 0 {
5546            struct_ser.serialize_field("contextId", &self.context_id)?;
5547        }
5548        if self.min_pinned_id != 0 {
5549            #[allow(clippy::needless_borrow)]
5550            #[allow(clippy::needless_borrows_for_generic_args)]
5551            struct_ser.serialize_field("minPinnedId", ToString::to_string(&self.min_pinned_id).as_str())?;
5552        }
5553        struct_ser.end()
5554    }
5555}
5556impl<'de> serde::Deserialize<'de> for HummockPinnedVersion {
5557    #[allow(deprecated)]
5558    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5559    where
5560        D: serde::Deserializer<'de>,
5561    {
5562        const FIELDS: &[&str] = &[
5563            "context_id",
5564            "contextId",
5565            "min_pinned_id",
5566            "minPinnedId",
5567        ];
5568
5569        #[allow(clippy::enum_variant_names)]
5570        enum GeneratedField {
5571            ContextId,
5572            MinPinnedId,
5573        }
5574        impl<'de> serde::Deserialize<'de> for GeneratedField {
5575            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5576            where
5577                D: serde::Deserializer<'de>,
5578            {
5579                struct GeneratedVisitor;
5580
5581                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5582                    type Value = GeneratedField;
5583
5584                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5585                        write!(formatter, "expected one of: {:?}", &FIELDS)
5586                    }
5587
5588                    #[allow(unused_variables)]
5589                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5590                    where
5591                        E: serde::de::Error,
5592                    {
5593                        match value {
5594                            "contextId" | "context_id" => Ok(GeneratedField::ContextId),
5595                            "minPinnedId" | "min_pinned_id" => Ok(GeneratedField::MinPinnedId),
5596                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5597                        }
5598                    }
5599                }
5600                deserializer.deserialize_identifier(GeneratedVisitor)
5601            }
5602        }
5603        struct GeneratedVisitor;
5604        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5605            type Value = HummockPinnedVersion;
5606
5607            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5608                formatter.write_str("struct hummock.HummockPinnedVersion")
5609            }
5610
5611            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockPinnedVersion, V::Error>
5612                where
5613                    V: serde::de::MapAccess<'de>,
5614            {
5615                let mut context_id__ = None;
5616                let mut min_pinned_id__ = None;
5617                while let Some(k) = map_.next_key()? {
5618                    match k {
5619                        GeneratedField::ContextId => {
5620                            if context_id__.is_some() {
5621                                return Err(serde::de::Error::duplicate_field("contextId"));
5622                            }
5623                            context_id__ = 
5624                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5625                            ;
5626                        }
5627                        GeneratedField::MinPinnedId => {
5628                            if min_pinned_id__.is_some() {
5629                                return Err(serde::de::Error::duplicate_field("minPinnedId"));
5630                            }
5631                            min_pinned_id__ = 
5632                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5633                            ;
5634                        }
5635                    }
5636                }
5637                Ok(HummockPinnedVersion {
5638                    context_id: context_id__.unwrap_or_default(),
5639                    min_pinned_id: min_pinned_id__.unwrap_or_default(),
5640                })
5641            }
5642        }
5643        deserializer.deserialize_struct("hummock.HummockPinnedVersion", FIELDS, GeneratedVisitor)
5644    }
5645}
5646impl serde::Serialize for HummockVersion {
5647    #[allow(deprecated)]
5648    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5649    where
5650        S: serde::Serializer,
5651    {
5652        use serde::ser::SerializeStruct;
5653        let mut len = 0;
5654        if self.id != 0 {
5655            len += 1;
5656        }
5657        if !self.levels.is_empty() {
5658            len += 1;
5659        }
5660        if self.max_committed_epoch != 0 {
5661            len += 1;
5662        }
5663        if !self.table_watermarks.is_empty() {
5664            len += 1;
5665        }
5666        if !self.table_change_logs.is_empty() {
5667            len += 1;
5668        }
5669        if !self.state_table_info.is_empty() {
5670            len += 1;
5671        }
5672        if !self.vector_indexes.is_empty() {
5673            len += 1;
5674        }
5675        let mut struct_ser = serializer.serialize_struct("hummock.HummockVersion", len)?;
5676        if self.id != 0 {
5677            #[allow(clippy::needless_borrow)]
5678            #[allow(clippy::needless_borrows_for_generic_args)]
5679            struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
5680        }
5681        if !self.levels.is_empty() {
5682            struct_ser.serialize_field("levels", &self.levels)?;
5683        }
5684        if self.max_committed_epoch != 0 {
5685            #[allow(clippy::needless_borrow)]
5686            #[allow(clippy::needless_borrows_for_generic_args)]
5687            struct_ser.serialize_field("maxCommittedEpoch", ToString::to_string(&self.max_committed_epoch).as_str())?;
5688        }
5689        if !self.table_watermarks.is_empty() {
5690            struct_ser.serialize_field("tableWatermarks", &self.table_watermarks)?;
5691        }
5692        if !self.table_change_logs.is_empty() {
5693            struct_ser.serialize_field("tableChangeLogs", &self.table_change_logs)?;
5694        }
5695        if !self.state_table_info.is_empty() {
5696            struct_ser.serialize_field("stateTableInfo", &self.state_table_info)?;
5697        }
5698        if !self.vector_indexes.is_empty() {
5699            struct_ser.serialize_field("vectorIndexes", &self.vector_indexes)?;
5700        }
5701        struct_ser.end()
5702    }
5703}
5704impl<'de> serde::Deserialize<'de> for HummockVersion {
5705    #[allow(deprecated)]
5706    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5707    where
5708        D: serde::Deserializer<'de>,
5709    {
5710        const FIELDS: &[&str] = &[
5711            "id",
5712            "levels",
5713            "max_committed_epoch",
5714            "maxCommittedEpoch",
5715            "table_watermarks",
5716            "tableWatermarks",
5717            "table_change_logs",
5718            "tableChangeLogs",
5719            "state_table_info",
5720            "stateTableInfo",
5721            "vector_indexes",
5722            "vectorIndexes",
5723        ];
5724
5725        #[allow(clippy::enum_variant_names)]
5726        enum GeneratedField {
5727            Id,
5728            Levels,
5729            MaxCommittedEpoch,
5730            TableWatermarks,
5731            TableChangeLogs,
5732            StateTableInfo,
5733            VectorIndexes,
5734        }
5735        impl<'de> serde::Deserialize<'de> for GeneratedField {
5736            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5737            where
5738                D: serde::Deserializer<'de>,
5739            {
5740                struct GeneratedVisitor;
5741
5742                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5743                    type Value = GeneratedField;
5744
5745                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5746                        write!(formatter, "expected one of: {:?}", &FIELDS)
5747                    }
5748
5749                    #[allow(unused_variables)]
5750                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5751                    where
5752                        E: serde::de::Error,
5753                    {
5754                        match value {
5755                            "id" => Ok(GeneratedField::Id),
5756                            "levels" => Ok(GeneratedField::Levels),
5757                            "maxCommittedEpoch" | "max_committed_epoch" => Ok(GeneratedField::MaxCommittedEpoch),
5758                            "tableWatermarks" | "table_watermarks" => Ok(GeneratedField::TableWatermarks),
5759                            "tableChangeLogs" | "table_change_logs" => Ok(GeneratedField::TableChangeLogs),
5760                            "stateTableInfo" | "state_table_info" => Ok(GeneratedField::StateTableInfo),
5761                            "vectorIndexes" | "vector_indexes" => Ok(GeneratedField::VectorIndexes),
5762                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5763                        }
5764                    }
5765                }
5766                deserializer.deserialize_identifier(GeneratedVisitor)
5767            }
5768        }
5769        struct GeneratedVisitor;
5770        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5771            type Value = HummockVersion;
5772
5773            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5774                formatter.write_str("struct hummock.HummockVersion")
5775            }
5776
5777            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersion, V::Error>
5778                where
5779                    V: serde::de::MapAccess<'de>,
5780            {
5781                let mut id__ = None;
5782                let mut levels__ = None;
5783                let mut max_committed_epoch__ = None;
5784                let mut table_watermarks__ = None;
5785                let mut table_change_logs__ = None;
5786                let mut state_table_info__ = None;
5787                let mut vector_indexes__ = None;
5788                while let Some(k) = map_.next_key()? {
5789                    match k {
5790                        GeneratedField::Id => {
5791                            if id__.is_some() {
5792                                return Err(serde::de::Error::duplicate_field("id"));
5793                            }
5794                            id__ = 
5795                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5796                            ;
5797                        }
5798                        GeneratedField::Levels => {
5799                            if levels__.is_some() {
5800                                return Err(serde::de::Error::duplicate_field("levels"));
5801                            }
5802                            levels__ = Some(
5803                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
5804                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
5805                            );
5806                        }
5807                        GeneratedField::MaxCommittedEpoch => {
5808                            if max_committed_epoch__.is_some() {
5809                                return Err(serde::de::Error::duplicate_field("maxCommittedEpoch"));
5810                            }
5811                            max_committed_epoch__ = 
5812                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5813                            ;
5814                        }
5815                        GeneratedField::TableWatermarks => {
5816                            if table_watermarks__.is_some() {
5817                                return Err(serde::de::Error::duplicate_field("tableWatermarks"));
5818                            }
5819                            table_watermarks__ = Some(
5820                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5821                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
5822                            );
5823                        }
5824                        GeneratedField::TableChangeLogs => {
5825                            if table_change_logs__.is_some() {
5826                                return Err(serde::de::Error::duplicate_field("tableChangeLogs"));
5827                            }
5828                            table_change_logs__ = Some(
5829                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5830                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
5831                            );
5832                        }
5833                        GeneratedField::StateTableInfo => {
5834                            if state_table_info__.is_some() {
5835                                return Err(serde::de::Error::duplicate_field("stateTableInfo"));
5836                            }
5837                            state_table_info__ = Some(
5838                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5839                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
5840                            );
5841                        }
5842                        GeneratedField::VectorIndexes => {
5843                            if vector_indexes__.is_some() {
5844                                return Err(serde::de::Error::duplicate_field("vectorIndexes"));
5845                            }
5846                            vector_indexes__ = Some(
5847                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5848                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
5849                            );
5850                        }
5851                    }
5852                }
5853                Ok(HummockVersion {
5854                    id: id__.unwrap_or_default(),
5855                    levels: levels__.unwrap_or_default(),
5856                    max_committed_epoch: max_committed_epoch__.unwrap_or_default(),
5857                    table_watermarks: table_watermarks__.unwrap_or_default(),
5858                    table_change_logs: table_change_logs__.unwrap_or_default(),
5859                    state_table_info: state_table_info__.unwrap_or_default(),
5860                    vector_indexes: vector_indexes__.unwrap_or_default(),
5861                })
5862            }
5863        }
5864        deserializer.deserialize_struct("hummock.HummockVersion", FIELDS, GeneratedVisitor)
5865    }
5866}
5867impl serde::Serialize for hummock_version::Levels {
5868    #[allow(deprecated)]
5869    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5870    where
5871        S: serde::Serializer,
5872    {
5873        use serde::ser::SerializeStruct;
5874        let mut len = 0;
5875        if !self.levels.is_empty() {
5876            len += 1;
5877        }
5878        if self.l0.is_some() {
5879            len += 1;
5880        }
5881        if self.group_id != 0 {
5882            len += 1;
5883        }
5884        if self.parent_group_id != 0 {
5885            len += 1;
5886        }
5887        if !self.member_table_ids.is_empty() {
5888            len += 1;
5889        }
5890        if self.compaction_group_version_id != 0 {
5891            len += 1;
5892        }
5893        let mut struct_ser = serializer.serialize_struct("hummock.HummockVersion.Levels", len)?;
5894        if !self.levels.is_empty() {
5895            struct_ser.serialize_field("levels", &self.levels)?;
5896        }
5897        if let Some(v) = self.l0.as_ref() {
5898            struct_ser.serialize_field("l0", v)?;
5899        }
5900        if self.group_id != 0 {
5901            #[allow(clippy::needless_borrow)]
5902            #[allow(clippy::needless_borrows_for_generic_args)]
5903            struct_ser.serialize_field("groupId", ToString::to_string(&self.group_id).as_str())?;
5904        }
5905        if self.parent_group_id != 0 {
5906            #[allow(clippy::needless_borrow)]
5907            #[allow(clippy::needless_borrows_for_generic_args)]
5908            struct_ser.serialize_field("parentGroupId", ToString::to_string(&self.parent_group_id).as_str())?;
5909        }
5910        if !self.member_table_ids.is_empty() {
5911            struct_ser.serialize_field("memberTableIds", &self.member_table_ids)?;
5912        }
5913        if self.compaction_group_version_id != 0 {
5914            #[allow(clippy::needless_borrow)]
5915            #[allow(clippy::needless_borrows_for_generic_args)]
5916            struct_ser.serialize_field("compactionGroupVersionId", ToString::to_string(&self.compaction_group_version_id).as_str())?;
5917        }
5918        struct_ser.end()
5919    }
5920}
5921impl<'de> serde::Deserialize<'de> for hummock_version::Levels {
5922    #[allow(deprecated)]
5923    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5924    where
5925        D: serde::Deserializer<'de>,
5926    {
5927        const FIELDS: &[&str] = &[
5928            "levels",
5929            "l0",
5930            "group_id",
5931            "groupId",
5932            "parent_group_id",
5933            "parentGroupId",
5934            "member_table_ids",
5935            "memberTableIds",
5936            "compaction_group_version_id",
5937            "compactionGroupVersionId",
5938        ];
5939
5940        #[allow(clippy::enum_variant_names)]
5941        enum GeneratedField {
5942            Levels,
5943            L0,
5944            GroupId,
5945            ParentGroupId,
5946            MemberTableIds,
5947            CompactionGroupVersionId,
5948        }
5949        impl<'de> serde::Deserialize<'de> for GeneratedField {
5950            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5951            where
5952                D: serde::Deserializer<'de>,
5953            {
5954                struct GeneratedVisitor;
5955
5956                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5957                    type Value = GeneratedField;
5958
5959                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5960                        write!(formatter, "expected one of: {:?}", &FIELDS)
5961                    }
5962
5963                    #[allow(unused_variables)]
5964                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5965                    where
5966                        E: serde::de::Error,
5967                    {
5968                        match value {
5969                            "levels" => Ok(GeneratedField::Levels),
5970                            "l0" => Ok(GeneratedField::L0),
5971                            "groupId" | "group_id" => Ok(GeneratedField::GroupId),
5972                            "parentGroupId" | "parent_group_id" => Ok(GeneratedField::ParentGroupId),
5973                            "memberTableIds" | "member_table_ids" => Ok(GeneratedField::MemberTableIds),
5974                            "compactionGroupVersionId" | "compaction_group_version_id" => Ok(GeneratedField::CompactionGroupVersionId),
5975                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5976                        }
5977                    }
5978                }
5979                deserializer.deserialize_identifier(GeneratedVisitor)
5980            }
5981        }
5982        struct GeneratedVisitor;
5983        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5984            type Value = hummock_version::Levels;
5985
5986            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5987                formatter.write_str("struct hummock.HummockVersion.Levels")
5988            }
5989
5990            fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version::Levels, V::Error>
5991                where
5992                    V: serde::de::MapAccess<'de>,
5993            {
5994                let mut levels__ = None;
5995                let mut l0__ = None;
5996                let mut group_id__ = None;
5997                let mut parent_group_id__ = None;
5998                let mut member_table_ids__ = None;
5999                let mut compaction_group_version_id__ = None;
6000                while let Some(k) = map_.next_key()? {
6001                    match k {
6002                        GeneratedField::Levels => {
6003                            if levels__.is_some() {
6004                                return Err(serde::de::Error::duplicate_field("levels"));
6005                            }
6006                            levels__ = Some(map_.next_value()?);
6007                        }
6008                        GeneratedField::L0 => {
6009                            if l0__.is_some() {
6010                                return Err(serde::de::Error::duplicate_field("l0"));
6011                            }
6012                            l0__ = map_.next_value()?;
6013                        }
6014                        GeneratedField::GroupId => {
6015                            if group_id__.is_some() {
6016                                return Err(serde::de::Error::duplicate_field("groupId"));
6017                            }
6018                            group_id__ = 
6019                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6020                            ;
6021                        }
6022                        GeneratedField::ParentGroupId => {
6023                            if parent_group_id__.is_some() {
6024                                return Err(serde::de::Error::duplicate_field("parentGroupId"));
6025                            }
6026                            parent_group_id__ = 
6027                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6028                            ;
6029                        }
6030                        GeneratedField::MemberTableIds => {
6031                            if member_table_ids__.is_some() {
6032                                return Err(serde::de::Error::duplicate_field("memberTableIds"));
6033                            }
6034                            member_table_ids__ = 
6035                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6036                                    .into_iter().map(|x| x.0).collect())
6037                            ;
6038                        }
6039                        GeneratedField::CompactionGroupVersionId => {
6040                            if compaction_group_version_id__.is_some() {
6041                                return Err(serde::de::Error::duplicate_field("compactionGroupVersionId"));
6042                            }
6043                            compaction_group_version_id__ = 
6044                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6045                            ;
6046                        }
6047                    }
6048                }
6049                Ok(hummock_version::Levels {
6050                    levels: levels__.unwrap_or_default(),
6051                    l0: l0__,
6052                    group_id: group_id__.unwrap_or_default(),
6053                    parent_group_id: parent_group_id__.unwrap_or_default(),
6054                    member_table_ids: member_table_ids__.unwrap_or_default(),
6055                    compaction_group_version_id: compaction_group_version_id__.unwrap_or_default(),
6056                })
6057            }
6058        }
6059        deserializer.deserialize_struct("hummock.HummockVersion.Levels", FIELDS, GeneratedVisitor)
6060    }
6061}
6062impl serde::Serialize for HummockVersionArchive {
6063    #[allow(deprecated)]
6064    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6065    where
6066        S: serde::Serializer,
6067    {
6068        use serde::ser::SerializeStruct;
6069        let mut len = 0;
6070        if self.version.is_some() {
6071            len += 1;
6072        }
6073        if !self.version_deltas.is_empty() {
6074            len += 1;
6075        }
6076        let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionArchive", len)?;
6077        if let Some(v) = self.version.as_ref() {
6078            struct_ser.serialize_field("version", v)?;
6079        }
6080        if !self.version_deltas.is_empty() {
6081            struct_ser.serialize_field("versionDeltas", &self.version_deltas)?;
6082        }
6083        struct_ser.end()
6084    }
6085}
6086impl<'de> serde::Deserialize<'de> for HummockVersionArchive {
6087    #[allow(deprecated)]
6088    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6089    where
6090        D: serde::Deserializer<'de>,
6091    {
6092        const FIELDS: &[&str] = &[
6093            "version",
6094            "version_deltas",
6095            "versionDeltas",
6096        ];
6097
6098        #[allow(clippy::enum_variant_names)]
6099        enum GeneratedField {
6100            Version,
6101            VersionDeltas,
6102        }
6103        impl<'de> serde::Deserialize<'de> for GeneratedField {
6104            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6105            where
6106                D: serde::Deserializer<'de>,
6107            {
6108                struct GeneratedVisitor;
6109
6110                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6111                    type Value = GeneratedField;
6112
6113                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6114                        write!(formatter, "expected one of: {:?}", &FIELDS)
6115                    }
6116
6117                    #[allow(unused_variables)]
6118                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6119                    where
6120                        E: serde::de::Error,
6121                    {
6122                        match value {
6123                            "version" => Ok(GeneratedField::Version),
6124                            "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
6125                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6126                        }
6127                    }
6128                }
6129                deserializer.deserialize_identifier(GeneratedVisitor)
6130            }
6131        }
6132        struct GeneratedVisitor;
6133        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6134            type Value = HummockVersionArchive;
6135
6136            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6137                formatter.write_str("struct hummock.HummockVersionArchive")
6138            }
6139
6140            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionArchive, V::Error>
6141                where
6142                    V: serde::de::MapAccess<'de>,
6143            {
6144                let mut version__ = None;
6145                let mut version_deltas__ = None;
6146                while let Some(k) = map_.next_key()? {
6147                    match k {
6148                        GeneratedField::Version => {
6149                            if version__.is_some() {
6150                                return Err(serde::de::Error::duplicate_field("version"));
6151                            }
6152                            version__ = map_.next_value()?;
6153                        }
6154                        GeneratedField::VersionDeltas => {
6155                            if version_deltas__.is_some() {
6156                                return Err(serde::de::Error::duplicate_field("versionDeltas"));
6157                            }
6158                            version_deltas__ = Some(map_.next_value()?);
6159                        }
6160                    }
6161                }
6162                Ok(HummockVersionArchive {
6163                    version: version__,
6164                    version_deltas: version_deltas__.unwrap_or_default(),
6165                })
6166            }
6167        }
6168        deserializer.deserialize_struct("hummock.HummockVersionArchive", FIELDS, GeneratedVisitor)
6169    }
6170}
6171impl serde::Serialize for HummockVersionCheckpoint {
6172    #[allow(deprecated)]
6173    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6174    where
6175        S: serde::Serializer,
6176    {
6177        use serde::ser::SerializeStruct;
6178        let mut len = 0;
6179        if self.version.is_some() {
6180            len += 1;
6181        }
6182        if !self.stale_objects.is_empty() {
6183            len += 1;
6184        }
6185        let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionCheckpoint", len)?;
6186        if let Some(v) = self.version.as_ref() {
6187            struct_ser.serialize_field("version", v)?;
6188        }
6189        if !self.stale_objects.is_empty() {
6190            struct_ser.serialize_field("staleObjects", &self.stale_objects)?;
6191        }
6192        struct_ser.end()
6193    }
6194}
6195impl<'de> serde::Deserialize<'de> for HummockVersionCheckpoint {
6196    #[allow(deprecated)]
6197    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6198    where
6199        D: serde::Deserializer<'de>,
6200    {
6201        const FIELDS: &[&str] = &[
6202            "version",
6203            "stale_objects",
6204            "staleObjects",
6205        ];
6206
6207        #[allow(clippy::enum_variant_names)]
6208        enum GeneratedField {
6209            Version,
6210            StaleObjects,
6211        }
6212        impl<'de> serde::Deserialize<'de> for GeneratedField {
6213            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6214            where
6215                D: serde::Deserializer<'de>,
6216            {
6217                struct GeneratedVisitor;
6218
6219                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6220                    type Value = GeneratedField;
6221
6222                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6223                        write!(formatter, "expected one of: {:?}", &FIELDS)
6224                    }
6225
6226                    #[allow(unused_variables)]
6227                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6228                    where
6229                        E: serde::de::Error,
6230                    {
6231                        match value {
6232                            "version" => Ok(GeneratedField::Version),
6233                            "staleObjects" | "stale_objects" => Ok(GeneratedField::StaleObjects),
6234                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6235                        }
6236                    }
6237                }
6238                deserializer.deserialize_identifier(GeneratedVisitor)
6239            }
6240        }
6241        struct GeneratedVisitor;
6242        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6243            type Value = HummockVersionCheckpoint;
6244
6245            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6246                formatter.write_str("struct hummock.HummockVersionCheckpoint")
6247            }
6248
6249            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionCheckpoint, V::Error>
6250                where
6251                    V: serde::de::MapAccess<'de>,
6252            {
6253                let mut version__ = None;
6254                let mut stale_objects__ = None;
6255                while let Some(k) = map_.next_key()? {
6256                    match k {
6257                        GeneratedField::Version => {
6258                            if version__.is_some() {
6259                                return Err(serde::de::Error::duplicate_field("version"));
6260                            }
6261                            version__ = map_.next_value()?;
6262                        }
6263                        GeneratedField::StaleObjects => {
6264                            if stale_objects__.is_some() {
6265                                return Err(serde::de::Error::duplicate_field("staleObjects"));
6266                            }
6267                            stale_objects__ = Some(
6268                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
6269                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
6270                            );
6271                        }
6272                    }
6273                }
6274                Ok(HummockVersionCheckpoint {
6275                    version: version__,
6276                    stale_objects: stale_objects__.unwrap_or_default(),
6277                })
6278            }
6279        }
6280        deserializer.deserialize_struct("hummock.HummockVersionCheckpoint", FIELDS, GeneratedVisitor)
6281    }
6282}
6283impl serde::Serialize for hummock_version_checkpoint::StaleObjects {
6284    #[allow(deprecated)]
6285    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6286    where
6287        S: serde::Serializer,
6288    {
6289        use serde::ser::SerializeStruct;
6290        let mut len = 0;
6291        if !self.id.is_empty() {
6292            len += 1;
6293        }
6294        if self.total_file_size != 0 {
6295            len += 1;
6296        }
6297        if !self.vector_files.is_empty() {
6298            len += 1;
6299        }
6300        let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionCheckpoint.StaleObjects", len)?;
6301        if !self.id.is_empty() {
6302            struct_ser.serialize_field("id", &self.id.iter().map(ToString::to_string).collect::<Vec<_>>())?;
6303        }
6304        if self.total_file_size != 0 {
6305            #[allow(clippy::needless_borrow)]
6306            #[allow(clippy::needless_borrows_for_generic_args)]
6307            struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
6308        }
6309        if !self.vector_files.is_empty() {
6310            struct_ser.serialize_field("vectorFiles", &self.vector_files)?;
6311        }
6312        struct_ser.end()
6313    }
6314}
6315impl<'de> serde::Deserialize<'de> for hummock_version_checkpoint::StaleObjects {
6316    #[allow(deprecated)]
6317    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6318    where
6319        D: serde::Deserializer<'de>,
6320    {
6321        const FIELDS: &[&str] = &[
6322            "id",
6323            "total_file_size",
6324            "totalFileSize",
6325            "vector_files",
6326            "vectorFiles",
6327        ];
6328
6329        #[allow(clippy::enum_variant_names)]
6330        enum GeneratedField {
6331            Id,
6332            TotalFileSize,
6333            VectorFiles,
6334        }
6335        impl<'de> serde::Deserialize<'de> for GeneratedField {
6336            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6337            where
6338                D: serde::Deserializer<'de>,
6339            {
6340                struct GeneratedVisitor;
6341
6342                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6343                    type Value = GeneratedField;
6344
6345                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6346                        write!(formatter, "expected one of: {:?}", &FIELDS)
6347                    }
6348
6349                    #[allow(unused_variables)]
6350                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6351                    where
6352                        E: serde::de::Error,
6353                    {
6354                        match value {
6355                            "id" => Ok(GeneratedField::Id),
6356                            "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
6357                            "vectorFiles" | "vector_files" => Ok(GeneratedField::VectorFiles),
6358                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6359                        }
6360                    }
6361                }
6362                deserializer.deserialize_identifier(GeneratedVisitor)
6363            }
6364        }
6365        struct GeneratedVisitor;
6366        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6367            type Value = hummock_version_checkpoint::StaleObjects;
6368
6369            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6370                formatter.write_str("struct hummock.HummockVersionCheckpoint.StaleObjects")
6371            }
6372
6373            fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version_checkpoint::StaleObjects, V::Error>
6374                where
6375                    V: serde::de::MapAccess<'de>,
6376            {
6377                let mut id__ = None;
6378                let mut total_file_size__ = None;
6379                let mut vector_files__ = None;
6380                while let Some(k) = map_.next_key()? {
6381                    match k {
6382                        GeneratedField::Id => {
6383                            if id__.is_some() {
6384                                return Err(serde::de::Error::duplicate_field("id"));
6385                            }
6386                            id__ = 
6387                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6388                                    .into_iter().map(|x| x.0).collect())
6389                            ;
6390                        }
6391                        GeneratedField::TotalFileSize => {
6392                            if total_file_size__.is_some() {
6393                                return Err(serde::de::Error::duplicate_field("totalFileSize"));
6394                            }
6395                            total_file_size__ = 
6396                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6397                            ;
6398                        }
6399                        GeneratedField::VectorFiles => {
6400                            if vector_files__.is_some() {
6401                                return Err(serde::de::Error::duplicate_field("vectorFiles"));
6402                            }
6403                            vector_files__ = Some(map_.next_value()?);
6404                        }
6405                    }
6406                }
6407                Ok(hummock_version_checkpoint::StaleObjects {
6408                    id: id__.unwrap_or_default(),
6409                    total_file_size: total_file_size__.unwrap_or_default(),
6410                    vector_files: vector_files__.unwrap_or_default(),
6411                })
6412            }
6413        }
6414        deserializer.deserialize_struct("hummock.HummockVersionCheckpoint.StaleObjects", FIELDS, GeneratedVisitor)
6415    }
6416}
6417impl serde::Serialize for HummockVersionDelta {
6418    #[allow(deprecated)]
6419    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6420    where
6421        S: serde::Serializer,
6422    {
6423        use serde::ser::SerializeStruct;
6424        let mut len = 0;
6425        if self.id != 0 {
6426            len += 1;
6427        }
6428        if self.prev_id != 0 {
6429            len += 1;
6430        }
6431        if !self.group_deltas.is_empty() {
6432            len += 1;
6433        }
6434        if self.max_committed_epoch != 0 {
6435            len += 1;
6436        }
6437        if self.trivial_move {
6438            len += 1;
6439        }
6440        if !self.new_table_watermarks.is_empty() {
6441            len += 1;
6442        }
6443        if !self.removed_table_ids.is_empty() {
6444            len += 1;
6445        }
6446        if !self.change_log_delta.is_empty() {
6447            len += 1;
6448        }
6449        if !self.state_table_info_delta.is_empty() {
6450            len += 1;
6451        }
6452        if !self.vector_index_delta.is_empty() {
6453            len += 1;
6454        }
6455        let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDelta", len)?;
6456        if self.id != 0 {
6457            #[allow(clippy::needless_borrow)]
6458            #[allow(clippy::needless_borrows_for_generic_args)]
6459            struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
6460        }
6461        if self.prev_id != 0 {
6462            #[allow(clippy::needless_borrow)]
6463            #[allow(clippy::needless_borrows_for_generic_args)]
6464            struct_ser.serialize_field("prevId", ToString::to_string(&self.prev_id).as_str())?;
6465        }
6466        if !self.group_deltas.is_empty() {
6467            struct_ser.serialize_field("groupDeltas", &self.group_deltas)?;
6468        }
6469        if self.max_committed_epoch != 0 {
6470            #[allow(clippy::needless_borrow)]
6471            #[allow(clippy::needless_borrows_for_generic_args)]
6472            struct_ser.serialize_field("maxCommittedEpoch", ToString::to_string(&self.max_committed_epoch).as_str())?;
6473        }
6474        if self.trivial_move {
6475            struct_ser.serialize_field("trivialMove", &self.trivial_move)?;
6476        }
6477        if !self.new_table_watermarks.is_empty() {
6478            struct_ser.serialize_field("newTableWatermarks", &self.new_table_watermarks)?;
6479        }
6480        if !self.removed_table_ids.is_empty() {
6481            struct_ser.serialize_field("removedTableIds", &self.removed_table_ids)?;
6482        }
6483        if !self.change_log_delta.is_empty() {
6484            struct_ser.serialize_field("changeLogDelta", &self.change_log_delta)?;
6485        }
6486        if !self.state_table_info_delta.is_empty() {
6487            struct_ser.serialize_field("stateTableInfoDelta", &self.state_table_info_delta)?;
6488        }
6489        if !self.vector_index_delta.is_empty() {
6490            struct_ser.serialize_field("vectorIndexDelta", &self.vector_index_delta)?;
6491        }
6492        struct_ser.end()
6493    }
6494}
6495impl<'de> serde::Deserialize<'de> for HummockVersionDelta {
6496    #[allow(deprecated)]
6497    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6498    where
6499        D: serde::Deserializer<'de>,
6500    {
6501        const FIELDS: &[&str] = &[
6502            "id",
6503            "prev_id",
6504            "prevId",
6505            "group_deltas",
6506            "groupDeltas",
6507            "max_committed_epoch",
6508            "maxCommittedEpoch",
6509            "trivial_move",
6510            "trivialMove",
6511            "new_table_watermarks",
6512            "newTableWatermarks",
6513            "removed_table_ids",
6514            "removedTableIds",
6515            "change_log_delta",
6516            "changeLogDelta",
6517            "state_table_info_delta",
6518            "stateTableInfoDelta",
6519            "vector_index_delta",
6520            "vectorIndexDelta",
6521        ];
6522
6523        #[allow(clippy::enum_variant_names)]
6524        enum GeneratedField {
6525            Id,
6526            PrevId,
6527            GroupDeltas,
6528            MaxCommittedEpoch,
6529            TrivialMove,
6530            NewTableWatermarks,
6531            RemovedTableIds,
6532            ChangeLogDelta,
6533            StateTableInfoDelta,
6534            VectorIndexDelta,
6535        }
6536        impl<'de> serde::Deserialize<'de> for GeneratedField {
6537            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6538            where
6539                D: serde::Deserializer<'de>,
6540            {
6541                struct GeneratedVisitor;
6542
6543                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6544                    type Value = GeneratedField;
6545
6546                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6547                        write!(formatter, "expected one of: {:?}", &FIELDS)
6548                    }
6549
6550                    #[allow(unused_variables)]
6551                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6552                    where
6553                        E: serde::de::Error,
6554                    {
6555                        match value {
6556                            "id" => Ok(GeneratedField::Id),
6557                            "prevId" | "prev_id" => Ok(GeneratedField::PrevId),
6558                            "groupDeltas" | "group_deltas" => Ok(GeneratedField::GroupDeltas),
6559                            "maxCommittedEpoch" | "max_committed_epoch" => Ok(GeneratedField::MaxCommittedEpoch),
6560                            "trivialMove" | "trivial_move" => Ok(GeneratedField::TrivialMove),
6561                            "newTableWatermarks" | "new_table_watermarks" => Ok(GeneratedField::NewTableWatermarks),
6562                            "removedTableIds" | "removed_table_ids" => Ok(GeneratedField::RemovedTableIds),
6563                            "changeLogDelta" | "change_log_delta" => Ok(GeneratedField::ChangeLogDelta),
6564                            "stateTableInfoDelta" | "state_table_info_delta" => Ok(GeneratedField::StateTableInfoDelta),
6565                            "vectorIndexDelta" | "vector_index_delta" => Ok(GeneratedField::VectorIndexDelta),
6566                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6567                        }
6568                    }
6569                }
6570                deserializer.deserialize_identifier(GeneratedVisitor)
6571            }
6572        }
6573        struct GeneratedVisitor;
6574        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6575            type Value = HummockVersionDelta;
6576
6577            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6578                formatter.write_str("struct hummock.HummockVersionDelta")
6579            }
6580
6581            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionDelta, V::Error>
6582                where
6583                    V: serde::de::MapAccess<'de>,
6584            {
6585                let mut id__ = None;
6586                let mut prev_id__ = None;
6587                let mut group_deltas__ = None;
6588                let mut max_committed_epoch__ = None;
6589                let mut trivial_move__ = None;
6590                let mut new_table_watermarks__ = None;
6591                let mut removed_table_ids__ = None;
6592                let mut change_log_delta__ = None;
6593                let mut state_table_info_delta__ = None;
6594                let mut vector_index_delta__ = None;
6595                while let Some(k) = map_.next_key()? {
6596                    match k {
6597                        GeneratedField::Id => {
6598                            if id__.is_some() {
6599                                return Err(serde::de::Error::duplicate_field("id"));
6600                            }
6601                            id__ = 
6602                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6603                            ;
6604                        }
6605                        GeneratedField::PrevId => {
6606                            if prev_id__.is_some() {
6607                                return Err(serde::de::Error::duplicate_field("prevId"));
6608                            }
6609                            prev_id__ = 
6610                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6611                            ;
6612                        }
6613                        GeneratedField::GroupDeltas => {
6614                            if group_deltas__.is_some() {
6615                                return Err(serde::de::Error::duplicate_field("groupDeltas"));
6616                            }
6617                            group_deltas__ = Some(
6618                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
6619                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
6620                            );
6621                        }
6622                        GeneratedField::MaxCommittedEpoch => {
6623                            if max_committed_epoch__.is_some() {
6624                                return Err(serde::de::Error::duplicate_field("maxCommittedEpoch"));
6625                            }
6626                            max_committed_epoch__ = 
6627                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6628                            ;
6629                        }
6630                        GeneratedField::TrivialMove => {
6631                            if trivial_move__.is_some() {
6632                                return Err(serde::de::Error::duplicate_field("trivialMove"));
6633                            }
6634                            trivial_move__ = Some(map_.next_value()?);
6635                        }
6636                        GeneratedField::NewTableWatermarks => {
6637                            if new_table_watermarks__.is_some() {
6638                                return Err(serde::de::Error::duplicate_field("newTableWatermarks"));
6639                            }
6640                            new_table_watermarks__ = Some(
6641                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6642                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
6643                            );
6644                        }
6645                        GeneratedField::RemovedTableIds => {
6646                            if removed_table_ids__.is_some() {
6647                                return Err(serde::de::Error::duplicate_field("removedTableIds"));
6648                            }
6649                            removed_table_ids__ = 
6650                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6651                                    .into_iter().map(|x| x.0).collect())
6652                            ;
6653                        }
6654                        GeneratedField::ChangeLogDelta => {
6655                            if change_log_delta__.is_some() {
6656                                return Err(serde::de::Error::duplicate_field("changeLogDelta"));
6657                            }
6658                            change_log_delta__ = Some(
6659                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6660                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
6661                            );
6662                        }
6663                        GeneratedField::StateTableInfoDelta => {
6664                            if state_table_info_delta__.is_some() {
6665                                return Err(serde::de::Error::duplicate_field("stateTableInfoDelta"));
6666                            }
6667                            state_table_info_delta__ = Some(
6668                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6669                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
6670                            );
6671                        }
6672                        GeneratedField::VectorIndexDelta => {
6673                            if vector_index_delta__.is_some() {
6674                                return Err(serde::de::Error::duplicate_field("vectorIndexDelta"));
6675                            }
6676                            vector_index_delta__ = Some(
6677                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6678                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
6679                            );
6680                        }
6681                    }
6682                }
6683                Ok(HummockVersionDelta {
6684                    id: id__.unwrap_or_default(),
6685                    prev_id: prev_id__.unwrap_or_default(),
6686                    group_deltas: group_deltas__.unwrap_or_default(),
6687                    max_committed_epoch: max_committed_epoch__.unwrap_or_default(),
6688                    trivial_move: trivial_move__.unwrap_or_default(),
6689                    new_table_watermarks: new_table_watermarks__.unwrap_or_default(),
6690                    removed_table_ids: removed_table_ids__.unwrap_or_default(),
6691                    change_log_delta: change_log_delta__.unwrap_or_default(),
6692                    state_table_info_delta: state_table_info_delta__.unwrap_or_default(),
6693                    vector_index_delta: vector_index_delta__.unwrap_or_default(),
6694                })
6695            }
6696        }
6697        deserializer.deserialize_struct("hummock.HummockVersionDelta", FIELDS, GeneratedVisitor)
6698    }
6699}
6700impl serde::Serialize for hummock_version_delta::ChangeLogDelta {
6701    #[allow(deprecated)]
6702    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6703    where
6704        S: serde::Serializer,
6705    {
6706        use serde::ser::SerializeStruct;
6707        let mut len = 0;
6708        if self.new_log.is_some() {
6709            len += 1;
6710        }
6711        if self.truncate_epoch != 0 {
6712            len += 1;
6713        }
6714        let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDelta.ChangeLogDelta", len)?;
6715        if let Some(v) = self.new_log.as_ref() {
6716            struct_ser.serialize_field("newLog", v)?;
6717        }
6718        if self.truncate_epoch != 0 {
6719            #[allow(clippy::needless_borrow)]
6720            #[allow(clippy::needless_borrows_for_generic_args)]
6721            struct_ser.serialize_field("truncateEpoch", ToString::to_string(&self.truncate_epoch).as_str())?;
6722        }
6723        struct_ser.end()
6724    }
6725}
6726impl<'de> serde::Deserialize<'de> for hummock_version_delta::ChangeLogDelta {
6727    #[allow(deprecated)]
6728    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6729    where
6730        D: serde::Deserializer<'de>,
6731    {
6732        const FIELDS: &[&str] = &[
6733            "new_log",
6734            "newLog",
6735            "truncate_epoch",
6736            "truncateEpoch",
6737        ];
6738
6739        #[allow(clippy::enum_variant_names)]
6740        enum GeneratedField {
6741            NewLog,
6742            TruncateEpoch,
6743        }
6744        impl<'de> serde::Deserialize<'de> for GeneratedField {
6745            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6746            where
6747                D: serde::Deserializer<'de>,
6748            {
6749                struct GeneratedVisitor;
6750
6751                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6752                    type Value = GeneratedField;
6753
6754                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6755                        write!(formatter, "expected one of: {:?}", &FIELDS)
6756                    }
6757
6758                    #[allow(unused_variables)]
6759                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6760                    where
6761                        E: serde::de::Error,
6762                    {
6763                        match value {
6764                            "newLog" | "new_log" => Ok(GeneratedField::NewLog),
6765                            "truncateEpoch" | "truncate_epoch" => Ok(GeneratedField::TruncateEpoch),
6766                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6767                        }
6768                    }
6769                }
6770                deserializer.deserialize_identifier(GeneratedVisitor)
6771            }
6772        }
6773        struct GeneratedVisitor;
6774        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6775            type Value = hummock_version_delta::ChangeLogDelta;
6776
6777            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6778                formatter.write_str("struct hummock.HummockVersionDelta.ChangeLogDelta")
6779            }
6780
6781            fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version_delta::ChangeLogDelta, V::Error>
6782                where
6783                    V: serde::de::MapAccess<'de>,
6784            {
6785                let mut new_log__ = None;
6786                let mut truncate_epoch__ = None;
6787                while let Some(k) = map_.next_key()? {
6788                    match k {
6789                        GeneratedField::NewLog => {
6790                            if new_log__.is_some() {
6791                                return Err(serde::de::Error::duplicate_field("newLog"));
6792                            }
6793                            new_log__ = map_.next_value()?;
6794                        }
6795                        GeneratedField::TruncateEpoch => {
6796                            if truncate_epoch__.is_some() {
6797                                return Err(serde::de::Error::duplicate_field("truncateEpoch"));
6798                            }
6799                            truncate_epoch__ = 
6800                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6801                            ;
6802                        }
6803                    }
6804                }
6805                Ok(hummock_version_delta::ChangeLogDelta {
6806                    new_log: new_log__,
6807                    truncate_epoch: truncate_epoch__.unwrap_or_default(),
6808                })
6809            }
6810        }
6811        deserializer.deserialize_struct("hummock.HummockVersionDelta.ChangeLogDelta", FIELDS, GeneratedVisitor)
6812    }
6813}
6814impl serde::Serialize for hummock_version_delta::GroupDeltas {
6815    #[allow(deprecated)]
6816    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6817    where
6818        S: serde::Serializer,
6819    {
6820        use serde::ser::SerializeStruct;
6821        let mut len = 0;
6822        if !self.group_deltas.is_empty() {
6823            len += 1;
6824        }
6825        let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDelta.GroupDeltas", len)?;
6826        if !self.group_deltas.is_empty() {
6827            struct_ser.serialize_field("groupDeltas", &self.group_deltas)?;
6828        }
6829        struct_ser.end()
6830    }
6831}
6832impl<'de> serde::Deserialize<'de> for hummock_version_delta::GroupDeltas {
6833    #[allow(deprecated)]
6834    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6835    where
6836        D: serde::Deserializer<'de>,
6837    {
6838        const FIELDS: &[&str] = &[
6839            "group_deltas",
6840            "groupDeltas",
6841        ];
6842
6843        #[allow(clippy::enum_variant_names)]
6844        enum GeneratedField {
6845            GroupDeltas,
6846        }
6847        impl<'de> serde::Deserialize<'de> for GeneratedField {
6848            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6849            where
6850                D: serde::Deserializer<'de>,
6851            {
6852                struct GeneratedVisitor;
6853
6854                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6855                    type Value = GeneratedField;
6856
6857                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6858                        write!(formatter, "expected one of: {:?}", &FIELDS)
6859                    }
6860
6861                    #[allow(unused_variables)]
6862                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6863                    where
6864                        E: serde::de::Error,
6865                    {
6866                        match value {
6867                            "groupDeltas" | "group_deltas" => Ok(GeneratedField::GroupDeltas),
6868                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6869                        }
6870                    }
6871                }
6872                deserializer.deserialize_identifier(GeneratedVisitor)
6873            }
6874        }
6875        struct GeneratedVisitor;
6876        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6877            type Value = hummock_version_delta::GroupDeltas;
6878
6879            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6880                formatter.write_str("struct hummock.HummockVersionDelta.GroupDeltas")
6881            }
6882
6883            fn visit_map<V>(self, mut map_: V) -> std::result::Result<hummock_version_delta::GroupDeltas, V::Error>
6884                where
6885                    V: serde::de::MapAccess<'de>,
6886            {
6887                let mut group_deltas__ = None;
6888                while let Some(k) = map_.next_key()? {
6889                    match k {
6890                        GeneratedField::GroupDeltas => {
6891                            if group_deltas__.is_some() {
6892                                return Err(serde::de::Error::duplicate_field("groupDeltas"));
6893                            }
6894                            group_deltas__ = Some(map_.next_value()?);
6895                        }
6896                    }
6897                }
6898                Ok(hummock_version_delta::GroupDeltas {
6899                    group_deltas: group_deltas__.unwrap_or_default(),
6900                })
6901            }
6902        }
6903        deserializer.deserialize_struct("hummock.HummockVersionDelta.GroupDeltas", FIELDS, GeneratedVisitor)
6904    }
6905}
6906impl serde::Serialize for HummockVersionDeltas {
6907    #[allow(deprecated)]
6908    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6909    where
6910        S: serde::Serializer,
6911    {
6912        use serde::ser::SerializeStruct;
6913        let mut len = 0;
6914        if !self.version_deltas.is_empty() {
6915            len += 1;
6916        }
6917        let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionDeltas", len)?;
6918        if !self.version_deltas.is_empty() {
6919            struct_ser.serialize_field("versionDeltas", &self.version_deltas)?;
6920        }
6921        struct_ser.end()
6922    }
6923}
6924impl<'de> serde::Deserialize<'de> for HummockVersionDeltas {
6925    #[allow(deprecated)]
6926    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6927    where
6928        D: serde::Deserializer<'de>,
6929    {
6930        const FIELDS: &[&str] = &[
6931            "version_deltas",
6932            "versionDeltas",
6933        ];
6934
6935        #[allow(clippy::enum_variant_names)]
6936        enum GeneratedField {
6937            VersionDeltas,
6938        }
6939        impl<'de> serde::Deserialize<'de> for GeneratedField {
6940            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6941            where
6942                D: serde::Deserializer<'de>,
6943            {
6944                struct GeneratedVisitor;
6945
6946                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6947                    type Value = GeneratedField;
6948
6949                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6950                        write!(formatter, "expected one of: {:?}", &FIELDS)
6951                    }
6952
6953                    #[allow(unused_variables)]
6954                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6955                    where
6956                        E: serde::de::Error,
6957                    {
6958                        match value {
6959                            "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
6960                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6961                        }
6962                    }
6963                }
6964                deserializer.deserialize_identifier(GeneratedVisitor)
6965            }
6966        }
6967        struct GeneratedVisitor;
6968        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6969            type Value = HummockVersionDeltas;
6970
6971            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6972                formatter.write_str("struct hummock.HummockVersionDeltas")
6973            }
6974
6975            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionDeltas, V::Error>
6976                where
6977                    V: serde::de::MapAccess<'de>,
6978            {
6979                let mut version_deltas__ = None;
6980                while let Some(k) = map_.next_key()? {
6981                    match k {
6982                        GeneratedField::VersionDeltas => {
6983                            if version_deltas__.is_some() {
6984                                return Err(serde::de::Error::duplicate_field("versionDeltas"));
6985                            }
6986                            version_deltas__ = Some(map_.next_value()?);
6987                        }
6988                    }
6989                }
6990                Ok(HummockVersionDeltas {
6991                    version_deltas: version_deltas__.unwrap_or_default(),
6992                })
6993            }
6994        }
6995        deserializer.deserialize_struct("hummock.HummockVersionDeltas", FIELDS, GeneratedVisitor)
6996    }
6997}
6998impl serde::Serialize for HummockVersionStats {
6999    #[allow(deprecated)]
7000    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7001    where
7002        S: serde::Serializer,
7003    {
7004        use serde::ser::SerializeStruct;
7005        let mut len = 0;
7006        if self.hummock_version_id != 0 {
7007            len += 1;
7008        }
7009        if !self.table_stats.is_empty() {
7010            len += 1;
7011        }
7012        let mut struct_ser = serializer.serialize_struct("hummock.HummockVersionStats", len)?;
7013        if self.hummock_version_id != 0 {
7014            #[allow(clippy::needless_borrow)]
7015            #[allow(clippy::needless_borrows_for_generic_args)]
7016            struct_ser.serialize_field("hummockVersionId", ToString::to_string(&self.hummock_version_id).as_str())?;
7017        }
7018        if !self.table_stats.is_empty() {
7019            struct_ser.serialize_field("tableStats", &self.table_stats)?;
7020        }
7021        struct_ser.end()
7022    }
7023}
7024impl<'de> serde::Deserialize<'de> for HummockVersionStats {
7025    #[allow(deprecated)]
7026    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7027    where
7028        D: serde::Deserializer<'de>,
7029    {
7030        const FIELDS: &[&str] = &[
7031            "hummock_version_id",
7032            "hummockVersionId",
7033            "table_stats",
7034            "tableStats",
7035        ];
7036
7037        #[allow(clippy::enum_variant_names)]
7038        enum GeneratedField {
7039            HummockVersionId,
7040            TableStats,
7041        }
7042        impl<'de> serde::Deserialize<'de> for GeneratedField {
7043            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7044            where
7045                D: serde::Deserializer<'de>,
7046            {
7047                struct GeneratedVisitor;
7048
7049                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7050                    type Value = GeneratedField;
7051
7052                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7053                        write!(formatter, "expected one of: {:?}", &FIELDS)
7054                    }
7055
7056                    #[allow(unused_variables)]
7057                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7058                    where
7059                        E: serde::de::Error,
7060                    {
7061                        match value {
7062                            "hummockVersionId" | "hummock_version_id" => Ok(GeneratedField::HummockVersionId),
7063                            "tableStats" | "table_stats" => Ok(GeneratedField::TableStats),
7064                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7065                        }
7066                    }
7067                }
7068                deserializer.deserialize_identifier(GeneratedVisitor)
7069            }
7070        }
7071        struct GeneratedVisitor;
7072        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7073            type Value = HummockVersionStats;
7074
7075            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7076                formatter.write_str("struct hummock.HummockVersionStats")
7077            }
7078
7079            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HummockVersionStats, V::Error>
7080                where
7081                    V: serde::de::MapAccess<'de>,
7082            {
7083                let mut hummock_version_id__ = None;
7084                let mut table_stats__ = None;
7085                while let Some(k) = map_.next_key()? {
7086                    match k {
7087                        GeneratedField::HummockVersionId => {
7088                            if hummock_version_id__.is_some() {
7089                                return Err(serde::de::Error::duplicate_field("hummockVersionId"));
7090                            }
7091                            hummock_version_id__ = 
7092                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7093                            ;
7094                        }
7095                        GeneratedField::TableStats => {
7096                            if table_stats__.is_some() {
7097                                return Err(serde::de::Error::duplicate_field("tableStats"));
7098                            }
7099                            table_stats__ = Some(
7100                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
7101                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
7102                            );
7103                        }
7104                    }
7105                }
7106                Ok(HummockVersionStats {
7107                    hummock_version_id: hummock_version_id__.unwrap_or_default(),
7108                    table_stats: table_stats__.unwrap_or_default(),
7109                })
7110            }
7111        }
7112        deserializer.deserialize_struct("hummock.HummockVersionStats", FIELDS, GeneratedVisitor)
7113    }
7114}
7115impl serde::Serialize for InitMetadataForReplayRequest {
7116    #[allow(deprecated)]
7117    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7118    where
7119        S: serde::Serializer,
7120    {
7121        use serde::ser::SerializeStruct;
7122        let mut len = 0;
7123        if !self.tables.is_empty() {
7124            len += 1;
7125        }
7126        if !self.compaction_groups.is_empty() {
7127            len += 1;
7128        }
7129        let mut struct_ser = serializer.serialize_struct("hummock.InitMetadataForReplayRequest", len)?;
7130        if !self.tables.is_empty() {
7131            struct_ser.serialize_field("tables", &self.tables)?;
7132        }
7133        if !self.compaction_groups.is_empty() {
7134            struct_ser.serialize_field("compactionGroups", &self.compaction_groups)?;
7135        }
7136        struct_ser.end()
7137    }
7138}
7139impl<'de> serde::Deserialize<'de> for InitMetadataForReplayRequest {
7140    #[allow(deprecated)]
7141    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7142    where
7143        D: serde::Deserializer<'de>,
7144    {
7145        const FIELDS: &[&str] = &[
7146            "tables",
7147            "compaction_groups",
7148            "compactionGroups",
7149        ];
7150
7151        #[allow(clippy::enum_variant_names)]
7152        enum GeneratedField {
7153            Tables,
7154            CompactionGroups,
7155        }
7156        impl<'de> serde::Deserialize<'de> for GeneratedField {
7157            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7158            where
7159                D: serde::Deserializer<'de>,
7160            {
7161                struct GeneratedVisitor;
7162
7163                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7164                    type Value = GeneratedField;
7165
7166                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7167                        write!(formatter, "expected one of: {:?}", &FIELDS)
7168                    }
7169
7170                    #[allow(unused_variables)]
7171                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7172                    where
7173                        E: serde::de::Error,
7174                    {
7175                        match value {
7176                            "tables" => Ok(GeneratedField::Tables),
7177                            "compactionGroups" | "compaction_groups" => Ok(GeneratedField::CompactionGroups),
7178                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7179                        }
7180                    }
7181                }
7182                deserializer.deserialize_identifier(GeneratedVisitor)
7183            }
7184        }
7185        struct GeneratedVisitor;
7186        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7187            type Value = InitMetadataForReplayRequest;
7188
7189            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7190                formatter.write_str("struct hummock.InitMetadataForReplayRequest")
7191            }
7192
7193            fn visit_map<V>(self, mut map_: V) -> std::result::Result<InitMetadataForReplayRequest, V::Error>
7194                where
7195                    V: serde::de::MapAccess<'de>,
7196            {
7197                let mut tables__ = None;
7198                let mut compaction_groups__ = None;
7199                while let Some(k) = map_.next_key()? {
7200                    match k {
7201                        GeneratedField::Tables => {
7202                            if tables__.is_some() {
7203                                return Err(serde::de::Error::duplicate_field("tables"));
7204                            }
7205                            tables__ = Some(map_.next_value()?);
7206                        }
7207                        GeneratedField::CompactionGroups => {
7208                            if compaction_groups__.is_some() {
7209                                return Err(serde::de::Error::duplicate_field("compactionGroups"));
7210                            }
7211                            compaction_groups__ = Some(map_.next_value()?);
7212                        }
7213                    }
7214                }
7215                Ok(InitMetadataForReplayRequest {
7216                    tables: tables__.unwrap_or_default(),
7217                    compaction_groups: compaction_groups__.unwrap_or_default(),
7218                })
7219            }
7220        }
7221        deserializer.deserialize_struct("hummock.InitMetadataForReplayRequest", FIELDS, GeneratedVisitor)
7222    }
7223}
7224impl serde::Serialize for InitMetadataForReplayResponse {
7225    #[allow(deprecated)]
7226    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7227    where
7228        S: serde::Serializer,
7229    {
7230        use serde::ser::SerializeStruct;
7231        let len = 0;
7232        let struct_ser = serializer.serialize_struct("hummock.InitMetadataForReplayResponse", len)?;
7233        struct_ser.end()
7234    }
7235}
7236impl<'de> serde::Deserialize<'de> for InitMetadataForReplayResponse {
7237    #[allow(deprecated)]
7238    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7239    where
7240        D: serde::Deserializer<'de>,
7241    {
7242        const FIELDS: &[&str] = &[
7243        ];
7244
7245        #[allow(clippy::enum_variant_names)]
7246        enum GeneratedField {
7247        }
7248        impl<'de> serde::Deserialize<'de> for GeneratedField {
7249            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7250            where
7251                D: serde::Deserializer<'de>,
7252            {
7253                struct GeneratedVisitor;
7254
7255                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7256                    type Value = GeneratedField;
7257
7258                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7259                        write!(formatter, "expected one of: {:?}", &FIELDS)
7260                    }
7261
7262                    #[allow(unused_variables)]
7263                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7264                    where
7265                        E: serde::de::Error,
7266                    {
7267                            Err(serde::de::Error::unknown_field(value, FIELDS))
7268                    }
7269                }
7270                deserializer.deserialize_identifier(GeneratedVisitor)
7271            }
7272        }
7273        struct GeneratedVisitor;
7274        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7275            type Value = InitMetadataForReplayResponse;
7276
7277            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7278                formatter.write_str("struct hummock.InitMetadataForReplayResponse")
7279            }
7280
7281            fn visit_map<V>(self, mut map_: V) -> std::result::Result<InitMetadataForReplayResponse, V::Error>
7282                where
7283                    V: serde::de::MapAccess<'de>,
7284            {
7285                while map_.next_key::<GeneratedField>()?.is_some() {
7286                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7287                }
7288                Ok(InitMetadataForReplayResponse {
7289                })
7290            }
7291        }
7292        deserializer.deserialize_struct("hummock.InitMetadataForReplayResponse", FIELDS, GeneratedVisitor)
7293    }
7294}
7295impl serde::Serialize for InputLevel {
7296    #[allow(deprecated)]
7297    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7298    where
7299        S: serde::Serializer,
7300    {
7301        use serde::ser::SerializeStruct;
7302        let mut len = 0;
7303        if self.level_idx != 0 {
7304            len += 1;
7305        }
7306        if self.level_type != 0 {
7307            len += 1;
7308        }
7309        if !self.table_infos.is_empty() {
7310            len += 1;
7311        }
7312        let mut struct_ser = serializer.serialize_struct("hummock.InputLevel", len)?;
7313        if self.level_idx != 0 {
7314            struct_ser.serialize_field("levelIdx", &self.level_idx)?;
7315        }
7316        if self.level_type != 0 {
7317            let v = LevelType::try_from(self.level_type)
7318                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.level_type)))?;
7319            struct_ser.serialize_field("levelType", &v)?;
7320        }
7321        if !self.table_infos.is_empty() {
7322            struct_ser.serialize_field("tableInfos", &self.table_infos)?;
7323        }
7324        struct_ser.end()
7325    }
7326}
7327impl<'de> serde::Deserialize<'de> for InputLevel {
7328    #[allow(deprecated)]
7329    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7330    where
7331        D: serde::Deserializer<'de>,
7332    {
7333        const FIELDS: &[&str] = &[
7334            "level_idx",
7335            "levelIdx",
7336            "level_type",
7337            "levelType",
7338            "table_infos",
7339            "tableInfos",
7340        ];
7341
7342        #[allow(clippy::enum_variant_names)]
7343        enum GeneratedField {
7344            LevelIdx,
7345            LevelType,
7346            TableInfos,
7347        }
7348        impl<'de> serde::Deserialize<'de> for GeneratedField {
7349            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7350            where
7351                D: serde::Deserializer<'de>,
7352            {
7353                struct GeneratedVisitor;
7354
7355                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7356                    type Value = GeneratedField;
7357
7358                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7359                        write!(formatter, "expected one of: {:?}", &FIELDS)
7360                    }
7361
7362                    #[allow(unused_variables)]
7363                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7364                    where
7365                        E: serde::de::Error,
7366                    {
7367                        match value {
7368                            "levelIdx" | "level_idx" => Ok(GeneratedField::LevelIdx),
7369                            "levelType" | "level_type" => Ok(GeneratedField::LevelType),
7370                            "tableInfos" | "table_infos" => Ok(GeneratedField::TableInfos),
7371                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7372                        }
7373                    }
7374                }
7375                deserializer.deserialize_identifier(GeneratedVisitor)
7376            }
7377        }
7378        struct GeneratedVisitor;
7379        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7380            type Value = InputLevel;
7381
7382            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7383                formatter.write_str("struct hummock.InputLevel")
7384            }
7385
7386            fn visit_map<V>(self, mut map_: V) -> std::result::Result<InputLevel, V::Error>
7387                where
7388                    V: serde::de::MapAccess<'de>,
7389            {
7390                let mut level_idx__ = None;
7391                let mut level_type__ = None;
7392                let mut table_infos__ = None;
7393                while let Some(k) = map_.next_key()? {
7394                    match k {
7395                        GeneratedField::LevelIdx => {
7396                            if level_idx__.is_some() {
7397                                return Err(serde::de::Error::duplicate_field("levelIdx"));
7398                            }
7399                            level_idx__ = 
7400                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7401                            ;
7402                        }
7403                        GeneratedField::LevelType => {
7404                            if level_type__.is_some() {
7405                                return Err(serde::de::Error::duplicate_field("levelType"));
7406                            }
7407                            level_type__ = Some(map_.next_value::<LevelType>()? as i32);
7408                        }
7409                        GeneratedField::TableInfos => {
7410                            if table_infos__.is_some() {
7411                                return Err(serde::de::Error::duplicate_field("tableInfos"));
7412                            }
7413                            table_infos__ = Some(map_.next_value()?);
7414                        }
7415                    }
7416                }
7417                Ok(InputLevel {
7418                    level_idx: level_idx__.unwrap_or_default(),
7419                    level_type: level_type__.unwrap_or_default(),
7420                    table_infos: table_infos__.unwrap_or_default(),
7421                })
7422            }
7423        }
7424        deserializer.deserialize_struct("hummock.InputLevel", FIELDS, GeneratedVisitor)
7425    }
7426}
7427impl serde::Serialize for IntraLevelDelta {
7428    #[allow(deprecated)]
7429    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7430    where
7431        S: serde::Serializer,
7432    {
7433        use serde::ser::SerializeStruct;
7434        let mut len = 0;
7435        if self.level_idx != 0 {
7436            len += 1;
7437        }
7438        if self.l0_sub_level_id != 0 {
7439            len += 1;
7440        }
7441        if !self.removed_table_ids.is_empty() {
7442            len += 1;
7443        }
7444        if !self.inserted_table_infos.is_empty() {
7445            len += 1;
7446        }
7447        if self.vnode_partition_count != 0 {
7448            len += 1;
7449        }
7450        if self.compaction_group_version_id != 0 {
7451            len += 1;
7452        }
7453        let mut struct_ser = serializer.serialize_struct("hummock.IntraLevelDelta", len)?;
7454        if self.level_idx != 0 {
7455            struct_ser.serialize_field("levelIdx", &self.level_idx)?;
7456        }
7457        if self.l0_sub_level_id != 0 {
7458            #[allow(clippy::needless_borrow)]
7459            #[allow(clippy::needless_borrows_for_generic_args)]
7460            struct_ser.serialize_field("l0SubLevelId", ToString::to_string(&self.l0_sub_level_id).as_str())?;
7461        }
7462        if !self.removed_table_ids.is_empty() {
7463            struct_ser.serialize_field("removedTableIds", &self.removed_table_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
7464        }
7465        if !self.inserted_table_infos.is_empty() {
7466            struct_ser.serialize_field("insertedTableInfos", &self.inserted_table_infos)?;
7467        }
7468        if self.vnode_partition_count != 0 {
7469            struct_ser.serialize_field("vnodePartitionCount", &self.vnode_partition_count)?;
7470        }
7471        if self.compaction_group_version_id != 0 {
7472            #[allow(clippy::needless_borrow)]
7473            #[allow(clippy::needless_borrows_for_generic_args)]
7474            struct_ser.serialize_field("compactionGroupVersionId", ToString::to_string(&self.compaction_group_version_id).as_str())?;
7475        }
7476        struct_ser.end()
7477    }
7478}
7479impl<'de> serde::Deserialize<'de> for IntraLevelDelta {
7480    #[allow(deprecated)]
7481    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7482    where
7483        D: serde::Deserializer<'de>,
7484    {
7485        const FIELDS: &[&str] = &[
7486            "level_idx",
7487            "levelIdx",
7488            "l0_sub_level_id",
7489            "l0SubLevelId",
7490            "removed_table_ids",
7491            "removedTableIds",
7492            "inserted_table_infos",
7493            "insertedTableInfos",
7494            "vnode_partition_count",
7495            "vnodePartitionCount",
7496            "compaction_group_version_id",
7497            "compactionGroupVersionId",
7498        ];
7499
7500        #[allow(clippy::enum_variant_names)]
7501        enum GeneratedField {
7502            LevelIdx,
7503            L0SubLevelId,
7504            RemovedTableIds,
7505            InsertedTableInfos,
7506            VnodePartitionCount,
7507            CompactionGroupVersionId,
7508        }
7509        impl<'de> serde::Deserialize<'de> for GeneratedField {
7510            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7511            where
7512                D: serde::Deserializer<'de>,
7513            {
7514                struct GeneratedVisitor;
7515
7516                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7517                    type Value = GeneratedField;
7518
7519                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7520                        write!(formatter, "expected one of: {:?}", &FIELDS)
7521                    }
7522
7523                    #[allow(unused_variables)]
7524                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7525                    where
7526                        E: serde::de::Error,
7527                    {
7528                        match value {
7529                            "levelIdx" | "level_idx" => Ok(GeneratedField::LevelIdx),
7530                            "l0SubLevelId" | "l0_sub_level_id" => Ok(GeneratedField::L0SubLevelId),
7531                            "removedTableIds" | "removed_table_ids" => Ok(GeneratedField::RemovedTableIds),
7532                            "insertedTableInfos" | "inserted_table_infos" => Ok(GeneratedField::InsertedTableInfos),
7533                            "vnodePartitionCount" | "vnode_partition_count" => Ok(GeneratedField::VnodePartitionCount),
7534                            "compactionGroupVersionId" | "compaction_group_version_id" => Ok(GeneratedField::CompactionGroupVersionId),
7535                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7536                        }
7537                    }
7538                }
7539                deserializer.deserialize_identifier(GeneratedVisitor)
7540            }
7541        }
7542        struct GeneratedVisitor;
7543        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7544            type Value = IntraLevelDelta;
7545
7546            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7547                formatter.write_str("struct hummock.IntraLevelDelta")
7548            }
7549
7550            fn visit_map<V>(self, mut map_: V) -> std::result::Result<IntraLevelDelta, V::Error>
7551                where
7552                    V: serde::de::MapAccess<'de>,
7553            {
7554                let mut level_idx__ = None;
7555                let mut l0_sub_level_id__ = None;
7556                let mut removed_table_ids__ = None;
7557                let mut inserted_table_infos__ = None;
7558                let mut vnode_partition_count__ = None;
7559                let mut compaction_group_version_id__ = None;
7560                while let Some(k) = map_.next_key()? {
7561                    match k {
7562                        GeneratedField::LevelIdx => {
7563                            if level_idx__.is_some() {
7564                                return Err(serde::de::Error::duplicate_field("levelIdx"));
7565                            }
7566                            level_idx__ = 
7567                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7568                            ;
7569                        }
7570                        GeneratedField::L0SubLevelId => {
7571                            if l0_sub_level_id__.is_some() {
7572                                return Err(serde::de::Error::duplicate_field("l0SubLevelId"));
7573                            }
7574                            l0_sub_level_id__ = 
7575                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7576                            ;
7577                        }
7578                        GeneratedField::RemovedTableIds => {
7579                            if removed_table_ids__.is_some() {
7580                                return Err(serde::de::Error::duplicate_field("removedTableIds"));
7581                            }
7582                            removed_table_ids__ = 
7583                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7584                                    .into_iter().map(|x| x.0).collect())
7585                            ;
7586                        }
7587                        GeneratedField::InsertedTableInfos => {
7588                            if inserted_table_infos__.is_some() {
7589                                return Err(serde::de::Error::duplicate_field("insertedTableInfos"));
7590                            }
7591                            inserted_table_infos__ = Some(map_.next_value()?);
7592                        }
7593                        GeneratedField::VnodePartitionCount => {
7594                            if vnode_partition_count__.is_some() {
7595                                return Err(serde::de::Error::duplicate_field("vnodePartitionCount"));
7596                            }
7597                            vnode_partition_count__ = 
7598                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7599                            ;
7600                        }
7601                        GeneratedField::CompactionGroupVersionId => {
7602                            if compaction_group_version_id__.is_some() {
7603                                return Err(serde::de::Error::duplicate_field("compactionGroupVersionId"));
7604                            }
7605                            compaction_group_version_id__ = 
7606                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7607                            ;
7608                        }
7609                    }
7610                }
7611                Ok(IntraLevelDelta {
7612                    level_idx: level_idx__.unwrap_or_default(),
7613                    l0_sub_level_id: l0_sub_level_id__.unwrap_or_default(),
7614                    removed_table_ids: removed_table_ids__.unwrap_or_default(),
7615                    inserted_table_infos: inserted_table_infos__.unwrap_or_default(),
7616                    vnode_partition_count: vnode_partition_count__.unwrap_or_default(),
7617                    compaction_group_version_id: compaction_group_version_id__.unwrap_or_default(),
7618                })
7619            }
7620        }
7621        deserializer.deserialize_struct("hummock.IntraLevelDelta", FIELDS, GeneratedVisitor)
7622    }
7623}
7624impl serde::Serialize for KeyRange {
7625    #[allow(deprecated)]
7626    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7627    where
7628        S: serde::Serializer,
7629    {
7630        use serde::ser::SerializeStruct;
7631        let mut len = 0;
7632        if !self.left.is_empty() {
7633            len += 1;
7634        }
7635        if !self.right.is_empty() {
7636            len += 1;
7637        }
7638        if self.right_exclusive {
7639            len += 1;
7640        }
7641        let mut struct_ser = serializer.serialize_struct("hummock.KeyRange", len)?;
7642        if !self.left.is_empty() {
7643            #[allow(clippy::needless_borrow)]
7644            #[allow(clippy::needless_borrows_for_generic_args)]
7645            struct_ser.serialize_field("left", pbjson::private::base64::encode(&self.left).as_str())?;
7646        }
7647        if !self.right.is_empty() {
7648            #[allow(clippy::needless_borrow)]
7649            #[allow(clippy::needless_borrows_for_generic_args)]
7650            struct_ser.serialize_field("right", pbjson::private::base64::encode(&self.right).as_str())?;
7651        }
7652        if self.right_exclusive {
7653            struct_ser.serialize_field("rightExclusive", &self.right_exclusive)?;
7654        }
7655        struct_ser.end()
7656    }
7657}
7658impl<'de> serde::Deserialize<'de> for KeyRange {
7659    #[allow(deprecated)]
7660    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7661    where
7662        D: serde::Deserializer<'de>,
7663    {
7664        const FIELDS: &[&str] = &[
7665            "left",
7666            "right",
7667            "right_exclusive",
7668            "rightExclusive",
7669        ];
7670
7671        #[allow(clippy::enum_variant_names)]
7672        enum GeneratedField {
7673            Left,
7674            Right,
7675            RightExclusive,
7676        }
7677        impl<'de> serde::Deserialize<'de> for GeneratedField {
7678            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7679            where
7680                D: serde::Deserializer<'de>,
7681            {
7682                struct GeneratedVisitor;
7683
7684                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7685                    type Value = GeneratedField;
7686
7687                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7688                        write!(formatter, "expected one of: {:?}", &FIELDS)
7689                    }
7690
7691                    #[allow(unused_variables)]
7692                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7693                    where
7694                        E: serde::de::Error,
7695                    {
7696                        match value {
7697                            "left" => Ok(GeneratedField::Left),
7698                            "right" => Ok(GeneratedField::Right),
7699                            "rightExclusive" | "right_exclusive" => Ok(GeneratedField::RightExclusive),
7700                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7701                        }
7702                    }
7703                }
7704                deserializer.deserialize_identifier(GeneratedVisitor)
7705            }
7706        }
7707        struct GeneratedVisitor;
7708        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7709            type Value = KeyRange;
7710
7711            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7712                formatter.write_str("struct hummock.KeyRange")
7713            }
7714
7715            fn visit_map<V>(self, mut map_: V) -> std::result::Result<KeyRange, V::Error>
7716                where
7717                    V: serde::de::MapAccess<'de>,
7718            {
7719                let mut left__ = None;
7720                let mut right__ = None;
7721                let mut right_exclusive__ = None;
7722                while let Some(k) = map_.next_key()? {
7723                    match k {
7724                        GeneratedField::Left => {
7725                            if left__.is_some() {
7726                                return Err(serde::de::Error::duplicate_field("left"));
7727                            }
7728                            left__ = 
7729                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
7730                            ;
7731                        }
7732                        GeneratedField::Right => {
7733                            if right__.is_some() {
7734                                return Err(serde::de::Error::duplicate_field("right"));
7735                            }
7736                            right__ = 
7737                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
7738                            ;
7739                        }
7740                        GeneratedField::RightExclusive => {
7741                            if right_exclusive__.is_some() {
7742                                return Err(serde::de::Error::duplicate_field("rightExclusive"));
7743                            }
7744                            right_exclusive__ = Some(map_.next_value()?);
7745                        }
7746                    }
7747                }
7748                Ok(KeyRange {
7749                    left: left__.unwrap_or_default(),
7750                    right: right__.unwrap_or_default(),
7751                    right_exclusive: right_exclusive__.unwrap_or_default(),
7752                })
7753            }
7754        }
7755        deserializer.deserialize_struct("hummock.KeyRange", FIELDS, GeneratedVisitor)
7756    }
7757}
7758impl serde::Serialize for Level {
7759    #[allow(deprecated)]
7760    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7761    where
7762        S: serde::Serializer,
7763    {
7764        use serde::ser::SerializeStruct;
7765        let mut len = 0;
7766        if self.level_idx != 0 {
7767            len += 1;
7768        }
7769        if self.level_type != 0 {
7770            len += 1;
7771        }
7772        if !self.table_infos.is_empty() {
7773            len += 1;
7774        }
7775        if self.total_file_size != 0 {
7776            len += 1;
7777        }
7778        if self.sub_level_id != 0 {
7779            len += 1;
7780        }
7781        if self.uncompressed_file_size != 0 {
7782            len += 1;
7783        }
7784        if self.vnode_partition_count != 0 {
7785            len += 1;
7786        }
7787        let mut struct_ser = serializer.serialize_struct("hummock.Level", len)?;
7788        if self.level_idx != 0 {
7789            struct_ser.serialize_field("levelIdx", &self.level_idx)?;
7790        }
7791        if self.level_type != 0 {
7792            let v = LevelType::try_from(self.level_type)
7793                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.level_type)))?;
7794            struct_ser.serialize_field("levelType", &v)?;
7795        }
7796        if !self.table_infos.is_empty() {
7797            struct_ser.serialize_field("tableInfos", &self.table_infos)?;
7798        }
7799        if self.total_file_size != 0 {
7800            #[allow(clippy::needless_borrow)]
7801            #[allow(clippy::needless_borrows_for_generic_args)]
7802            struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
7803        }
7804        if self.sub_level_id != 0 {
7805            #[allow(clippy::needless_borrow)]
7806            #[allow(clippy::needless_borrows_for_generic_args)]
7807            struct_ser.serialize_field("subLevelId", ToString::to_string(&self.sub_level_id).as_str())?;
7808        }
7809        if self.uncompressed_file_size != 0 {
7810            #[allow(clippy::needless_borrow)]
7811            #[allow(clippy::needless_borrows_for_generic_args)]
7812            struct_ser.serialize_field("uncompressedFileSize", ToString::to_string(&self.uncompressed_file_size).as_str())?;
7813        }
7814        if self.vnode_partition_count != 0 {
7815            struct_ser.serialize_field("vnodePartitionCount", &self.vnode_partition_count)?;
7816        }
7817        struct_ser.end()
7818    }
7819}
7820impl<'de> serde::Deserialize<'de> for Level {
7821    #[allow(deprecated)]
7822    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7823    where
7824        D: serde::Deserializer<'de>,
7825    {
7826        const FIELDS: &[&str] = &[
7827            "level_idx",
7828            "levelIdx",
7829            "level_type",
7830            "levelType",
7831            "table_infos",
7832            "tableInfos",
7833            "total_file_size",
7834            "totalFileSize",
7835            "sub_level_id",
7836            "subLevelId",
7837            "uncompressed_file_size",
7838            "uncompressedFileSize",
7839            "vnode_partition_count",
7840            "vnodePartitionCount",
7841        ];
7842
7843        #[allow(clippy::enum_variant_names)]
7844        enum GeneratedField {
7845            LevelIdx,
7846            LevelType,
7847            TableInfos,
7848            TotalFileSize,
7849            SubLevelId,
7850            UncompressedFileSize,
7851            VnodePartitionCount,
7852        }
7853        impl<'de> serde::Deserialize<'de> for GeneratedField {
7854            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7855            where
7856                D: serde::Deserializer<'de>,
7857            {
7858                struct GeneratedVisitor;
7859
7860                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7861                    type Value = GeneratedField;
7862
7863                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7864                        write!(formatter, "expected one of: {:?}", &FIELDS)
7865                    }
7866
7867                    #[allow(unused_variables)]
7868                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7869                    where
7870                        E: serde::de::Error,
7871                    {
7872                        match value {
7873                            "levelIdx" | "level_idx" => Ok(GeneratedField::LevelIdx),
7874                            "levelType" | "level_type" => Ok(GeneratedField::LevelType),
7875                            "tableInfos" | "table_infos" => Ok(GeneratedField::TableInfos),
7876                            "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
7877                            "subLevelId" | "sub_level_id" => Ok(GeneratedField::SubLevelId),
7878                            "uncompressedFileSize" | "uncompressed_file_size" => Ok(GeneratedField::UncompressedFileSize),
7879                            "vnodePartitionCount" | "vnode_partition_count" => Ok(GeneratedField::VnodePartitionCount),
7880                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7881                        }
7882                    }
7883                }
7884                deserializer.deserialize_identifier(GeneratedVisitor)
7885            }
7886        }
7887        struct GeneratedVisitor;
7888        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7889            type Value = Level;
7890
7891            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7892                formatter.write_str("struct hummock.Level")
7893            }
7894
7895            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Level, V::Error>
7896                where
7897                    V: serde::de::MapAccess<'de>,
7898            {
7899                let mut level_idx__ = None;
7900                let mut level_type__ = None;
7901                let mut table_infos__ = None;
7902                let mut total_file_size__ = None;
7903                let mut sub_level_id__ = None;
7904                let mut uncompressed_file_size__ = None;
7905                let mut vnode_partition_count__ = None;
7906                while let Some(k) = map_.next_key()? {
7907                    match k {
7908                        GeneratedField::LevelIdx => {
7909                            if level_idx__.is_some() {
7910                                return Err(serde::de::Error::duplicate_field("levelIdx"));
7911                            }
7912                            level_idx__ = 
7913                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7914                            ;
7915                        }
7916                        GeneratedField::LevelType => {
7917                            if level_type__.is_some() {
7918                                return Err(serde::de::Error::duplicate_field("levelType"));
7919                            }
7920                            level_type__ = Some(map_.next_value::<LevelType>()? as i32);
7921                        }
7922                        GeneratedField::TableInfos => {
7923                            if table_infos__.is_some() {
7924                                return Err(serde::de::Error::duplicate_field("tableInfos"));
7925                            }
7926                            table_infos__ = Some(map_.next_value()?);
7927                        }
7928                        GeneratedField::TotalFileSize => {
7929                            if total_file_size__.is_some() {
7930                                return Err(serde::de::Error::duplicate_field("totalFileSize"));
7931                            }
7932                            total_file_size__ = 
7933                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7934                            ;
7935                        }
7936                        GeneratedField::SubLevelId => {
7937                            if sub_level_id__.is_some() {
7938                                return Err(serde::de::Error::duplicate_field("subLevelId"));
7939                            }
7940                            sub_level_id__ = 
7941                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7942                            ;
7943                        }
7944                        GeneratedField::UncompressedFileSize => {
7945                            if uncompressed_file_size__.is_some() {
7946                                return Err(serde::de::Error::duplicate_field("uncompressedFileSize"));
7947                            }
7948                            uncompressed_file_size__ = 
7949                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7950                            ;
7951                        }
7952                        GeneratedField::VnodePartitionCount => {
7953                            if vnode_partition_count__.is_some() {
7954                                return Err(serde::de::Error::duplicate_field("vnodePartitionCount"));
7955                            }
7956                            vnode_partition_count__ = 
7957                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7958                            ;
7959                        }
7960                    }
7961                }
7962                Ok(Level {
7963                    level_idx: level_idx__.unwrap_or_default(),
7964                    level_type: level_type__.unwrap_or_default(),
7965                    table_infos: table_infos__.unwrap_or_default(),
7966                    total_file_size: total_file_size__.unwrap_or_default(),
7967                    sub_level_id: sub_level_id__.unwrap_or_default(),
7968                    uncompressed_file_size: uncompressed_file_size__.unwrap_or_default(),
7969                    vnode_partition_count: vnode_partition_count__.unwrap_or_default(),
7970                })
7971            }
7972        }
7973        deserializer.deserialize_struct("hummock.Level", FIELDS, GeneratedVisitor)
7974    }
7975}
7976impl serde::Serialize for LevelHandler {
7977    #[allow(deprecated)]
7978    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7979    where
7980        S: serde::Serializer,
7981    {
7982        use serde::ser::SerializeStruct;
7983        let mut len = 0;
7984        if self.level != 0 {
7985            len += 1;
7986        }
7987        if !self.tasks.is_empty() {
7988            len += 1;
7989        }
7990        let mut struct_ser = serializer.serialize_struct("hummock.LevelHandler", len)?;
7991        if self.level != 0 {
7992            struct_ser.serialize_field("level", &self.level)?;
7993        }
7994        if !self.tasks.is_empty() {
7995            struct_ser.serialize_field("tasks", &self.tasks)?;
7996        }
7997        struct_ser.end()
7998    }
7999}
8000impl<'de> serde::Deserialize<'de> for LevelHandler {
8001    #[allow(deprecated)]
8002    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8003    where
8004        D: serde::Deserializer<'de>,
8005    {
8006        const FIELDS: &[&str] = &[
8007            "level",
8008            "tasks",
8009        ];
8010
8011        #[allow(clippy::enum_variant_names)]
8012        enum GeneratedField {
8013            Level,
8014            Tasks,
8015        }
8016        impl<'de> serde::Deserialize<'de> for GeneratedField {
8017            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8018            where
8019                D: serde::Deserializer<'de>,
8020            {
8021                struct GeneratedVisitor;
8022
8023                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8024                    type Value = GeneratedField;
8025
8026                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8027                        write!(formatter, "expected one of: {:?}", &FIELDS)
8028                    }
8029
8030                    #[allow(unused_variables)]
8031                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8032                    where
8033                        E: serde::de::Error,
8034                    {
8035                        match value {
8036                            "level" => Ok(GeneratedField::Level),
8037                            "tasks" => Ok(GeneratedField::Tasks),
8038                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8039                        }
8040                    }
8041                }
8042                deserializer.deserialize_identifier(GeneratedVisitor)
8043            }
8044        }
8045        struct GeneratedVisitor;
8046        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8047            type Value = LevelHandler;
8048
8049            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8050                formatter.write_str("struct hummock.LevelHandler")
8051            }
8052
8053            fn visit_map<V>(self, mut map_: V) -> std::result::Result<LevelHandler, V::Error>
8054                where
8055                    V: serde::de::MapAccess<'de>,
8056            {
8057                let mut level__ = None;
8058                let mut tasks__ = None;
8059                while let Some(k) = map_.next_key()? {
8060                    match k {
8061                        GeneratedField::Level => {
8062                            if level__.is_some() {
8063                                return Err(serde::de::Error::duplicate_field("level"));
8064                            }
8065                            level__ = 
8066                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8067                            ;
8068                        }
8069                        GeneratedField::Tasks => {
8070                            if tasks__.is_some() {
8071                                return Err(serde::de::Error::duplicate_field("tasks"));
8072                            }
8073                            tasks__ = Some(map_.next_value()?);
8074                        }
8075                    }
8076                }
8077                Ok(LevelHandler {
8078                    level: level__.unwrap_or_default(),
8079                    tasks: tasks__.unwrap_or_default(),
8080                })
8081            }
8082        }
8083        deserializer.deserialize_struct("hummock.LevelHandler", FIELDS, GeneratedVisitor)
8084    }
8085}
8086impl serde::Serialize for level_handler::RunningCompactTask {
8087    #[allow(deprecated)]
8088    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8089    where
8090        S: serde::Serializer,
8091    {
8092        use serde::ser::SerializeStruct;
8093        let mut len = 0;
8094        if self.task_id != 0 {
8095            len += 1;
8096        }
8097        if !self.ssts.is_empty() {
8098            len += 1;
8099        }
8100        if self.total_file_size != 0 {
8101            len += 1;
8102        }
8103        if self.target_level != 0 {
8104            len += 1;
8105        }
8106        let mut struct_ser = serializer.serialize_struct("hummock.LevelHandler.RunningCompactTask", len)?;
8107        if self.task_id != 0 {
8108            #[allow(clippy::needless_borrow)]
8109            #[allow(clippy::needless_borrows_for_generic_args)]
8110            struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
8111        }
8112        if !self.ssts.is_empty() {
8113            struct_ser.serialize_field("ssts", &self.ssts.iter().map(ToString::to_string).collect::<Vec<_>>())?;
8114        }
8115        if self.total_file_size != 0 {
8116            #[allow(clippy::needless_borrow)]
8117            #[allow(clippy::needless_borrows_for_generic_args)]
8118            struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
8119        }
8120        if self.target_level != 0 {
8121            struct_ser.serialize_field("targetLevel", &self.target_level)?;
8122        }
8123        struct_ser.end()
8124    }
8125}
8126impl<'de> serde::Deserialize<'de> for level_handler::RunningCompactTask {
8127    #[allow(deprecated)]
8128    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8129    where
8130        D: serde::Deserializer<'de>,
8131    {
8132        const FIELDS: &[&str] = &[
8133            "task_id",
8134            "taskId",
8135            "ssts",
8136            "total_file_size",
8137            "totalFileSize",
8138            "target_level",
8139            "targetLevel",
8140        ];
8141
8142        #[allow(clippy::enum_variant_names)]
8143        enum GeneratedField {
8144            TaskId,
8145            Ssts,
8146            TotalFileSize,
8147            TargetLevel,
8148        }
8149        impl<'de> serde::Deserialize<'de> for GeneratedField {
8150            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8151            where
8152                D: serde::Deserializer<'de>,
8153            {
8154                struct GeneratedVisitor;
8155
8156                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8157                    type Value = GeneratedField;
8158
8159                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8160                        write!(formatter, "expected one of: {:?}", &FIELDS)
8161                    }
8162
8163                    #[allow(unused_variables)]
8164                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8165                    where
8166                        E: serde::de::Error,
8167                    {
8168                        match value {
8169                            "taskId" | "task_id" => Ok(GeneratedField::TaskId),
8170                            "ssts" => Ok(GeneratedField::Ssts),
8171                            "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
8172                            "targetLevel" | "target_level" => Ok(GeneratedField::TargetLevel),
8173                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8174                        }
8175                    }
8176                }
8177                deserializer.deserialize_identifier(GeneratedVisitor)
8178            }
8179        }
8180        struct GeneratedVisitor;
8181        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8182            type Value = level_handler::RunningCompactTask;
8183
8184            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8185                formatter.write_str("struct hummock.LevelHandler.RunningCompactTask")
8186            }
8187
8188            fn visit_map<V>(self, mut map_: V) -> std::result::Result<level_handler::RunningCompactTask, V::Error>
8189                where
8190                    V: serde::de::MapAccess<'de>,
8191            {
8192                let mut task_id__ = None;
8193                let mut ssts__ = None;
8194                let mut total_file_size__ = None;
8195                let mut target_level__ = None;
8196                while let Some(k) = map_.next_key()? {
8197                    match k {
8198                        GeneratedField::TaskId => {
8199                            if task_id__.is_some() {
8200                                return Err(serde::de::Error::duplicate_field("taskId"));
8201                            }
8202                            task_id__ = 
8203                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8204                            ;
8205                        }
8206                        GeneratedField::Ssts => {
8207                            if ssts__.is_some() {
8208                                return Err(serde::de::Error::duplicate_field("ssts"));
8209                            }
8210                            ssts__ = 
8211                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8212                                    .into_iter().map(|x| x.0).collect())
8213                            ;
8214                        }
8215                        GeneratedField::TotalFileSize => {
8216                            if total_file_size__.is_some() {
8217                                return Err(serde::de::Error::duplicate_field("totalFileSize"));
8218                            }
8219                            total_file_size__ = 
8220                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8221                            ;
8222                        }
8223                        GeneratedField::TargetLevel => {
8224                            if target_level__.is_some() {
8225                                return Err(serde::de::Error::duplicate_field("targetLevel"));
8226                            }
8227                            target_level__ = 
8228                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8229                            ;
8230                        }
8231                    }
8232                }
8233                Ok(level_handler::RunningCompactTask {
8234                    task_id: task_id__.unwrap_or_default(),
8235                    ssts: ssts__.unwrap_or_default(),
8236                    total_file_size: total_file_size__.unwrap_or_default(),
8237                    target_level: target_level__.unwrap_or_default(),
8238                })
8239            }
8240        }
8241        deserializer.deserialize_struct("hummock.LevelHandler.RunningCompactTask", FIELDS, GeneratedVisitor)
8242    }
8243}
8244impl serde::Serialize for LevelType {
8245    #[allow(deprecated)]
8246    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8247    where
8248        S: serde::Serializer,
8249    {
8250        let variant = match self {
8251            Self::Unspecified => "LEVEL_TYPE_UNSPECIFIED",
8252            Self::Nonoverlapping => "LEVEL_TYPE_NONOVERLAPPING",
8253            Self::Overlapping => "LEVEL_TYPE_OVERLAPPING",
8254        };
8255        serializer.serialize_str(variant)
8256    }
8257}
8258impl<'de> serde::Deserialize<'de> for LevelType {
8259    #[allow(deprecated)]
8260    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8261    where
8262        D: serde::Deserializer<'de>,
8263    {
8264        const FIELDS: &[&str] = &[
8265            "LEVEL_TYPE_UNSPECIFIED",
8266            "LEVEL_TYPE_NONOVERLAPPING",
8267            "LEVEL_TYPE_OVERLAPPING",
8268        ];
8269
8270        struct GeneratedVisitor;
8271
8272        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8273            type Value = LevelType;
8274
8275            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8276                write!(formatter, "expected one of: {:?}", &FIELDS)
8277            }
8278
8279            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
8280            where
8281                E: serde::de::Error,
8282            {
8283                i32::try_from(v)
8284                    .ok()
8285                    .and_then(|x| x.try_into().ok())
8286                    .ok_or_else(|| {
8287                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
8288                    })
8289            }
8290
8291            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
8292            where
8293                E: serde::de::Error,
8294            {
8295                i32::try_from(v)
8296                    .ok()
8297                    .and_then(|x| x.try_into().ok())
8298                    .ok_or_else(|| {
8299                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
8300                    })
8301            }
8302
8303            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
8304            where
8305                E: serde::de::Error,
8306            {
8307                match value {
8308                    "LEVEL_TYPE_UNSPECIFIED" => Ok(LevelType::Unspecified),
8309                    "LEVEL_TYPE_NONOVERLAPPING" => Ok(LevelType::Nonoverlapping),
8310                    "LEVEL_TYPE_OVERLAPPING" => Ok(LevelType::Overlapping),
8311                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
8312                }
8313            }
8314        }
8315        deserializer.deserialize_any(GeneratedVisitor)
8316    }
8317}
8318impl serde::Serialize for ListActiveWriteLimitRequest {
8319    #[allow(deprecated)]
8320    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8321    where
8322        S: serde::Serializer,
8323    {
8324        use serde::ser::SerializeStruct;
8325        let len = 0;
8326        let struct_ser = serializer.serialize_struct("hummock.ListActiveWriteLimitRequest", len)?;
8327        struct_ser.end()
8328    }
8329}
8330impl<'de> serde::Deserialize<'de> for ListActiveWriteLimitRequest {
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        ];
8338
8339        #[allow(clippy::enum_variant_names)]
8340        enum GeneratedField {
8341        }
8342        impl<'de> serde::Deserialize<'de> for GeneratedField {
8343            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8344            where
8345                D: serde::Deserializer<'de>,
8346            {
8347                struct GeneratedVisitor;
8348
8349                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8350                    type Value = GeneratedField;
8351
8352                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8353                        write!(formatter, "expected one of: {:?}", &FIELDS)
8354                    }
8355
8356                    #[allow(unused_variables)]
8357                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8358                    where
8359                        E: serde::de::Error,
8360                    {
8361                            Err(serde::de::Error::unknown_field(value, FIELDS))
8362                    }
8363                }
8364                deserializer.deserialize_identifier(GeneratedVisitor)
8365            }
8366        }
8367        struct GeneratedVisitor;
8368        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8369            type Value = ListActiveWriteLimitRequest;
8370
8371            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8372                formatter.write_str("struct hummock.ListActiveWriteLimitRequest")
8373            }
8374
8375            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActiveWriteLimitRequest, V::Error>
8376                where
8377                    V: serde::de::MapAccess<'de>,
8378            {
8379                while map_.next_key::<GeneratedField>()?.is_some() {
8380                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8381                }
8382                Ok(ListActiveWriteLimitRequest {
8383                })
8384            }
8385        }
8386        deserializer.deserialize_struct("hummock.ListActiveWriteLimitRequest", FIELDS, GeneratedVisitor)
8387    }
8388}
8389impl serde::Serialize for ListActiveWriteLimitResponse {
8390    #[allow(deprecated)]
8391    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8392    where
8393        S: serde::Serializer,
8394    {
8395        use serde::ser::SerializeStruct;
8396        let mut len = 0;
8397        if !self.write_limits.is_empty() {
8398            len += 1;
8399        }
8400        let mut struct_ser = serializer.serialize_struct("hummock.ListActiveWriteLimitResponse", len)?;
8401        if !self.write_limits.is_empty() {
8402            struct_ser.serialize_field("writeLimits", &self.write_limits)?;
8403        }
8404        struct_ser.end()
8405    }
8406}
8407impl<'de> serde::Deserialize<'de> for ListActiveWriteLimitResponse {
8408    #[allow(deprecated)]
8409    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8410    where
8411        D: serde::Deserializer<'de>,
8412    {
8413        const FIELDS: &[&str] = &[
8414            "write_limits",
8415            "writeLimits",
8416        ];
8417
8418        #[allow(clippy::enum_variant_names)]
8419        enum GeneratedField {
8420            WriteLimits,
8421        }
8422        impl<'de> serde::Deserialize<'de> for GeneratedField {
8423            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8424            where
8425                D: serde::Deserializer<'de>,
8426            {
8427                struct GeneratedVisitor;
8428
8429                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8430                    type Value = GeneratedField;
8431
8432                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8433                        write!(formatter, "expected one of: {:?}", &FIELDS)
8434                    }
8435
8436                    #[allow(unused_variables)]
8437                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8438                    where
8439                        E: serde::de::Error,
8440                    {
8441                        match value {
8442                            "writeLimits" | "write_limits" => Ok(GeneratedField::WriteLimits),
8443                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8444                        }
8445                    }
8446                }
8447                deserializer.deserialize_identifier(GeneratedVisitor)
8448            }
8449        }
8450        struct GeneratedVisitor;
8451        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8452            type Value = ListActiveWriteLimitResponse;
8453
8454            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8455                formatter.write_str("struct hummock.ListActiveWriteLimitResponse")
8456            }
8457
8458            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActiveWriteLimitResponse, V::Error>
8459                where
8460                    V: serde::de::MapAccess<'de>,
8461            {
8462                let mut write_limits__ = None;
8463                while let Some(k) = map_.next_key()? {
8464                    match k {
8465                        GeneratedField::WriteLimits => {
8466                            if write_limits__.is_some() {
8467                                return Err(serde::de::Error::duplicate_field("writeLimits"));
8468                            }
8469                            write_limits__ = Some(
8470                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
8471                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
8472                            );
8473                        }
8474                    }
8475                }
8476                Ok(ListActiveWriteLimitResponse {
8477                    write_limits: write_limits__.unwrap_or_default(),
8478                })
8479            }
8480        }
8481        deserializer.deserialize_struct("hummock.ListActiveWriteLimitResponse", FIELDS, GeneratedVisitor)
8482    }
8483}
8484impl serde::Serialize for ListBranchedObjectRequest {
8485    #[allow(deprecated)]
8486    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8487    where
8488        S: serde::Serializer,
8489    {
8490        use serde::ser::SerializeStruct;
8491        let len = 0;
8492        let struct_ser = serializer.serialize_struct("hummock.ListBranchedObjectRequest", len)?;
8493        struct_ser.end()
8494    }
8495}
8496impl<'de> serde::Deserialize<'de> for ListBranchedObjectRequest {
8497    #[allow(deprecated)]
8498    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8499    where
8500        D: serde::Deserializer<'de>,
8501    {
8502        const FIELDS: &[&str] = &[
8503        ];
8504
8505        #[allow(clippy::enum_variant_names)]
8506        enum GeneratedField {
8507        }
8508        impl<'de> serde::Deserialize<'de> for GeneratedField {
8509            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8510            where
8511                D: serde::Deserializer<'de>,
8512            {
8513                struct GeneratedVisitor;
8514
8515                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8516                    type Value = GeneratedField;
8517
8518                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8519                        write!(formatter, "expected one of: {:?}", &FIELDS)
8520                    }
8521
8522                    #[allow(unused_variables)]
8523                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8524                    where
8525                        E: serde::de::Error,
8526                    {
8527                            Err(serde::de::Error::unknown_field(value, FIELDS))
8528                    }
8529                }
8530                deserializer.deserialize_identifier(GeneratedVisitor)
8531            }
8532        }
8533        struct GeneratedVisitor;
8534        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8535            type Value = ListBranchedObjectRequest;
8536
8537            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8538                formatter.write_str("struct hummock.ListBranchedObjectRequest")
8539            }
8540
8541            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListBranchedObjectRequest, V::Error>
8542                where
8543                    V: serde::de::MapAccess<'de>,
8544            {
8545                while map_.next_key::<GeneratedField>()?.is_some() {
8546                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8547                }
8548                Ok(ListBranchedObjectRequest {
8549                })
8550            }
8551        }
8552        deserializer.deserialize_struct("hummock.ListBranchedObjectRequest", FIELDS, GeneratedVisitor)
8553    }
8554}
8555impl serde::Serialize for ListBranchedObjectResponse {
8556    #[allow(deprecated)]
8557    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8558    where
8559        S: serde::Serializer,
8560    {
8561        use serde::ser::SerializeStruct;
8562        let mut len = 0;
8563        if !self.branched_objects.is_empty() {
8564            len += 1;
8565        }
8566        let mut struct_ser = serializer.serialize_struct("hummock.ListBranchedObjectResponse", len)?;
8567        if !self.branched_objects.is_empty() {
8568            struct_ser.serialize_field("branchedObjects", &self.branched_objects)?;
8569        }
8570        struct_ser.end()
8571    }
8572}
8573impl<'de> serde::Deserialize<'de> for ListBranchedObjectResponse {
8574    #[allow(deprecated)]
8575    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8576    where
8577        D: serde::Deserializer<'de>,
8578    {
8579        const FIELDS: &[&str] = &[
8580            "branched_objects",
8581            "branchedObjects",
8582        ];
8583
8584        #[allow(clippy::enum_variant_names)]
8585        enum GeneratedField {
8586            BranchedObjects,
8587        }
8588        impl<'de> serde::Deserialize<'de> for GeneratedField {
8589            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8590            where
8591                D: serde::Deserializer<'de>,
8592            {
8593                struct GeneratedVisitor;
8594
8595                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8596                    type Value = GeneratedField;
8597
8598                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8599                        write!(formatter, "expected one of: {:?}", &FIELDS)
8600                    }
8601
8602                    #[allow(unused_variables)]
8603                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8604                    where
8605                        E: serde::de::Error,
8606                    {
8607                        match value {
8608                            "branchedObjects" | "branched_objects" => Ok(GeneratedField::BranchedObjects),
8609                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8610                        }
8611                    }
8612                }
8613                deserializer.deserialize_identifier(GeneratedVisitor)
8614            }
8615        }
8616        struct GeneratedVisitor;
8617        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8618            type Value = ListBranchedObjectResponse;
8619
8620            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8621                formatter.write_str("struct hummock.ListBranchedObjectResponse")
8622            }
8623
8624            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListBranchedObjectResponse, V::Error>
8625                where
8626                    V: serde::de::MapAccess<'de>,
8627            {
8628                let mut branched_objects__ = None;
8629                while let Some(k) = map_.next_key()? {
8630                    match k {
8631                        GeneratedField::BranchedObjects => {
8632                            if branched_objects__.is_some() {
8633                                return Err(serde::de::Error::duplicate_field("branchedObjects"));
8634                            }
8635                            branched_objects__ = Some(map_.next_value()?);
8636                        }
8637                    }
8638                }
8639                Ok(ListBranchedObjectResponse {
8640                    branched_objects: branched_objects__.unwrap_or_default(),
8641                })
8642            }
8643        }
8644        deserializer.deserialize_struct("hummock.ListBranchedObjectResponse", FIELDS, GeneratedVisitor)
8645    }
8646}
8647impl serde::Serialize for ListCompactTaskAssignmentRequest {
8648    #[allow(deprecated)]
8649    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8650    where
8651        S: serde::Serializer,
8652    {
8653        use serde::ser::SerializeStruct;
8654        let len = 0;
8655        let struct_ser = serializer.serialize_struct("hummock.ListCompactTaskAssignmentRequest", len)?;
8656        struct_ser.end()
8657    }
8658}
8659impl<'de> serde::Deserialize<'de> for ListCompactTaskAssignmentRequest {
8660    #[allow(deprecated)]
8661    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8662    where
8663        D: serde::Deserializer<'de>,
8664    {
8665        const FIELDS: &[&str] = &[
8666        ];
8667
8668        #[allow(clippy::enum_variant_names)]
8669        enum GeneratedField {
8670        }
8671        impl<'de> serde::Deserialize<'de> for GeneratedField {
8672            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8673            where
8674                D: serde::Deserializer<'de>,
8675            {
8676                struct GeneratedVisitor;
8677
8678                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8679                    type Value = GeneratedField;
8680
8681                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8682                        write!(formatter, "expected one of: {:?}", &FIELDS)
8683                    }
8684
8685                    #[allow(unused_variables)]
8686                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8687                    where
8688                        E: serde::de::Error,
8689                    {
8690                            Err(serde::de::Error::unknown_field(value, FIELDS))
8691                    }
8692                }
8693                deserializer.deserialize_identifier(GeneratedVisitor)
8694            }
8695        }
8696        struct GeneratedVisitor;
8697        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8698            type Value = ListCompactTaskAssignmentRequest;
8699
8700            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8701                formatter.write_str("struct hummock.ListCompactTaskAssignmentRequest")
8702            }
8703
8704            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskAssignmentRequest, V::Error>
8705                where
8706                    V: serde::de::MapAccess<'de>,
8707            {
8708                while map_.next_key::<GeneratedField>()?.is_some() {
8709                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8710                }
8711                Ok(ListCompactTaskAssignmentRequest {
8712                })
8713            }
8714        }
8715        deserializer.deserialize_struct("hummock.ListCompactTaskAssignmentRequest", FIELDS, GeneratedVisitor)
8716    }
8717}
8718impl serde::Serialize for ListCompactTaskAssignmentResponse {
8719    #[allow(deprecated)]
8720    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8721    where
8722        S: serde::Serializer,
8723    {
8724        use serde::ser::SerializeStruct;
8725        let mut len = 0;
8726        if !self.task_assignment.is_empty() {
8727            len += 1;
8728        }
8729        let mut struct_ser = serializer.serialize_struct("hummock.ListCompactTaskAssignmentResponse", len)?;
8730        if !self.task_assignment.is_empty() {
8731            struct_ser.serialize_field("taskAssignment", &self.task_assignment)?;
8732        }
8733        struct_ser.end()
8734    }
8735}
8736impl<'de> serde::Deserialize<'de> for ListCompactTaskAssignmentResponse {
8737    #[allow(deprecated)]
8738    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8739    where
8740        D: serde::Deserializer<'de>,
8741    {
8742        const FIELDS: &[&str] = &[
8743            "task_assignment",
8744            "taskAssignment",
8745        ];
8746
8747        #[allow(clippy::enum_variant_names)]
8748        enum GeneratedField {
8749            TaskAssignment,
8750        }
8751        impl<'de> serde::Deserialize<'de> for GeneratedField {
8752            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8753            where
8754                D: serde::Deserializer<'de>,
8755            {
8756                struct GeneratedVisitor;
8757
8758                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8759                    type Value = GeneratedField;
8760
8761                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8762                        write!(formatter, "expected one of: {:?}", &FIELDS)
8763                    }
8764
8765                    #[allow(unused_variables)]
8766                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8767                    where
8768                        E: serde::de::Error,
8769                    {
8770                        match value {
8771                            "taskAssignment" | "task_assignment" => Ok(GeneratedField::TaskAssignment),
8772                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8773                        }
8774                    }
8775                }
8776                deserializer.deserialize_identifier(GeneratedVisitor)
8777            }
8778        }
8779        struct GeneratedVisitor;
8780        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8781            type Value = ListCompactTaskAssignmentResponse;
8782
8783            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8784                formatter.write_str("struct hummock.ListCompactTaskAssignmentResponse")
8785            }
8786
8787            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskAssignmentResponse, V::Error>
8788                where
8789                    V: serde::de::MapAccess<'de>,
8790            {
8791                let mut task_assignment__ = None;
8792                while let Some(k) = map_.next_key()? {
8793                    match k {
8794                        GeneratedField::TaskAssignment => {
8795                            if task_assignment__.is_some() {
8796                                return Err(serde::de::Error::duplicate_field("taskAssignment"));
8797                            }
8798                            task_assignment__ = Some(map_.next_value()?);
8799                        }
8800                    }
8801                }
8802                Ok(ListCompactTaskAssignmentResponse {
8803                    task_assignment: task_assignment__.unwrap_or_default(),
8804                })
8805            }
8806        }
8807        deserializer.deserialize_struct("hummock.ListCompactTaskAssignmentResponse", FIELDS, GeneratedVisitor)
8808    }
8809}
8810impl serde::Serialize for ListCompactTaskProgressRequest {
8811    #[allow(deprecated)]
8812    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8813    where
8814        S: serde::Serializer,
8815    {
8816        use serde::ser::SerializeStruct;
8817        let len = 0;
8818        let struct_ser = serializer.serialize_struct("hummock.ListCompactTaskProgressRequest", len)?;
8819        struct_ser.end()
8820    }
8821}
8822impl<'de> serde::Deserialize<'de> for ListCompactTaskProgressRequest {
8823    #[allow(deprecated)]
8824    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8825    where
8826        D: serde::Deserializer<'de>,
8827    {
8828        const FIELDS: &[&str] = &[
8829        ];
8830
8831        #[allow(clippy::enum_variant_names)]
8832        enum GeneratedField {
8833        }
8834        impl<'de> serde::Deserialize<'de> for GeneratedField {
8835            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8836            where
8837                D: serde::Deserializer<'de>,
8838            {
8839                struct GeneratedVisitor;
8840
8841                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8842                    type Value = GeneratedField;
8843
8844                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8845                        write!(formatter, "expected one of: {:?}", &FIELDS)
8846                    }
8847
8848                    #[allow(unused_variables)]
8849                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8850                    where
8851                        E: serde::de::Error,
8852                    {
8853                            Err(serde::de::Error::unknown_field(value, FIELDS))
8854                    }
8855                }
8856                deserializer.deserialize_identifier(GeneratedVisitor)
8857            }
8858        }
8859        struct GeneratedVisitor;
8860        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8861            type Value = ListCompactTaskProgressRequest;
8862
8863            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8864                formatter.write_str("struct hummock.ListCompactTaskProgressRequest")
8865            }
8866
8867            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskProgressRequest, V::Error>
8868                where
8869                    V: serde::de::MapAccess<'de>,
8870            {
8871                while map_.next_key::<GeneratedField>()?.is_some() {
8872                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8873                }
8874                Ok(ListCompactTaskProgressRequest {
8875                })
8876            }
8877        }
8878        deserializer.deserialize_struct("hummock.ListCompactTaskProgressRequest", FIELDS, GeneratedVisitor)
8879    }
8880}
8881impl serde::Serialize for ListCompactTaskProgressResponse {
8882    #[allow(deprecated)]
8883    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8884    where
8885        S: serde::Serializer,
8886    {
8887        use serde::ser::SerializeStruct;
8888        let mut len = 0;
8889        if !self.task_progress.is_empty() {
8890            len += 1;
8891        }
8892        let mut struct_ser = serializer.serialize_struct("hummock.ListCompactTaskProgressResponse", len)?;
8893        if !self.task_progress.is_empty() {
8894            struct_ser.serialize_field("taskProgress", &self.task_progress)?;
8895        }
8896        struct_ser.end()
8897    }
8898}
8899impl<'de> serde::Deserialize<'de> for ListCompactTaskProgressResponse {
8900    #[allow(deprecated)]
8901    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8902    where
8903        D: serde::Deserializer<'de>,
8904    {
8905        const FIELDS: &[&str] = &[
8906            "task_progress",
8907            "taskProgress",
8908        ];
8909
8910        #[allow(clippy::enum_variant_names)]
8911        enum GeneratedField {
8912            TaskProgress,
8913        }
8914        impl<'de> serde::Deserialize<'de> for GeneratedField {
8915            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8916            where
8917                D: serde::Deserializer<'de>,
8918            {
8919                struct GeneratedVisitor;
8920
8921                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8922                    type Value = GeneratedField;
8923
8924                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8925                        write!(formatter, "expected one of: {:?}", &FIELDS)
8926                    }
8927
8928                    #[allow(unused_variables)]
8929                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8930                    where
8931                        E: serde::de::Error,
8932                    {
8933                        match value {
8934                            "taskProgress" | "task_progress" => Ok(GeneratedField::TaskProgress),
8935                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8936                        }
8937                    }
8938                }
8939                deserializer.deserialize_identifier(GeneratedVisitor)
8940            }
8941        }
8942        struct GeneratedVisitor;
8943        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8944            type Value = ListCompactTaskProgressResponse;
8945
8946            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8947                formatter.write_str("struct hummock.ListCompactTaskProgressResponse")
8948            }
8949
8950            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCompactTaskProgressResponse, V::Error>
8951                where
8952                    V: serde::de::MapAccess<'de>,
8953            {
8954                let mut task_progress__ = None;
8955                while let Some(k) = map_.next_key()? {
8956                    match k {
8957                        GeneratedField::TaskProgress => {
8958                            if task_progress__.is_some() {
8959                                return Err(serde::de::Error::duplicate_field("taskProgress"));
8960                            }
8961                            task_progress__ = Some(map_.next_value()?);
8962                        }
8963                    }
8964                }
8965                Ok(ListCompactTaskProgressResponse {
8966                    task_progress: task_progress__.unwrap_or_default(),
8967                })
8968            }
8969        }
8970        deserializer.deserialize_struct("hummock.ListCompactTaskProgressResponse", FIELDS, GeneratedVisitor)
8971    }
8972}
8973impl serde::Serialize for ListHummockMetaConfigRequest {
8974    #[allow(deprecated)]
8975    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8976    where
8977        S: serde::Serializer,
8978    {
8979        use serde::ser::SerializeStruct;
8980        let len = 0;
8981        let struct_ser = serializer.serialize_struct("hummock.ListHummockMetaConfigRequest", len)?;
8982        struct_ser.end()
8983    }
8984}
8985impl<'de> serde::Deserialize<'de> for ListHummockMetaConfigRequest {
8986    #[allow(deprecated)]
8987    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8988    where
8989        D: serde::Deserializer<'de>,
8990    {
8991        const FIELDS: &[&str] = &[
8992        ];
8993
8994        #[allow(clippy::enum_variant_names)]
8995        enum GeneratedField {
8996        }
8997        impl<'de> serde::Deserialize<'de> for GeneratedField {
8998            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8999            where
9000                D: serde::Deserializer<'de>,
9001            {
9002                struct GeneratedVisitor;
9003
9004                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9005                    type Value = GeneratedField;
9006
9007                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9008                        write!(formatter, "expected one of: {:?}", &FIELDS)
9009                    }
9010
9011                    #[allow(unused_variables)]
9012                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9013                    where
9014                        E: serde::de::Error,
9015                    {
9016                            Err(serde::de::Error::unknown_field(value, FIELDS))
9017                    }
9018                }
9019                deserializer.deserialize_identifier(GeneratedVisitor)
9020            }
9021        }
9022        struct GeneratedVisitor;
9023        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9024            type Value = ListHummockMetaConfigRequest;
9025
9026            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9027                formatter.write_str("struct hummock.ListHummockMetaConfigRequest")
9028            }
9029
9030            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListHummockMetaConfigRequest, V::Error>
9031                where
9032                    V: serde::de::MapAccess<'de>,
9033            {
9034                while map_.next_key::<GeneratedField>()?.is_some() {
9035                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9036                }
9037                Ok(ListHummockMetaConfigRequest {
9038                })
9039            }
9040        }
9041        deserializer.deserialize_struct("hummock.ListHummockMetaConfigRequest", FIELDS, GeneratedVisitor)
9042    }
9043}
9044impl serde::Serialize for ListHummockMetaConfigResponse {
9045    #[allow(deprecated)]
9046    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9047    where
9048        S: serde::Serializer,
9049    {
9050        use serde::ser::SerializeStruct;
9051        let mut len = 0;
9052        if !self.configs.is_empty() {
9053            len += 1;
9054        }
9055        let mut struct_ser = serializer.serialize_struct("hummock.ListHummockMetaConfigResponse", len)?;
9056        if !self.configs.is_empty() {
9057            struct_ser.serialize_field("configs", &self.configs)?;
9058        }
9059        struct_ser.end()
9060    }
9061}
9062impl<'de> serde::Deserialize<'de> for ListHummockMetaConfigResponse {
9063    #[allow(deprecated)]
9064    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9065    where
9066        D: serde::Deserializer<'de>,
9067    {
9068        const FIELDS: &[&str] = &[
9069            "configs",
9070        ];
9071
9072        #[allow(clippy::enum_variant_names)]
9073        enum GeneratedField {
9074            Configs,
9075        }
9076        impl<'de> serde::Deserialize<'de> for GeneratedField {
9077            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9078            where
9079                D: serde::Deserializer<'de>,
9080            {
9081                struct GeneratedVisitor;
9082
9083                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9084                    type Value = GeneratedField;
9085
9086                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9087                        write!(formatter, "expected one of: {:?}", &FIELDS)
9088                    }
9089
9090                    #[allow(unused_variables)]
9091                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9092                    where
9093                        E: serde::de::Error,
9094                    {
9095                        match value {
9096                            "configs" => Ok(GeneratedField::Configs),
9097                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9098                        }
9099                    }
9100                }
9101                deserializer.deserialize_identifier(GeneratedVisitor)
9102            }
9103        }
9104        struct GeneratedVisitor;
9105        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9106            type Value = ListHummockMetaConfigResponse;
9107
9108            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9109                formatter.write_str("struct hummock.ListHummockMetaConfigResponse")
9110            }
9111
9112            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListHummockMetaConfigResponse, V::Error>
9113                where
9114                    V: serde::de::MapAccess<'de>,
9115            {
9116                let mut configs__ = None;
9117                while let Some(k) = map_.next_key()? {
9118                    match k {
9119                        GeneratedField::Configs => {
9120                            if configs__.is_some() {
9121                                return Err(serde::de::Error::duplicate_field("configs"));
9122                            }
9123                            configs__ = Some(
9124                                map_.next_value::<std::collections::HashMap<_, _>>()?
9125                            );
9126                        }
9127                    }
9128                }
9129                Ok(ListHummockMetaConfigResponse {
9130                    configs: configs__.unwrap_or_default(),
9131                })
9132            }
9133        }
9134        deserializer.deserialize_struct("hummock.ListHummockMetaConfigResponse", FIELDS, GeneratedVisitor)
9135    }
9136}
9137impl serde::Serialize for ListVersionDeltasRequest {
9138    #[allow(deprecated)]
9139    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9140    where
9141        S: serde::Serializer,
9142    {
9143        use serde::ser::SerializeStruct;
9144        let mut len = 0;
9145        if self.start_id != 0 {
9146            len += 1;
9147        }
9148        if self.num_limit != 0 {
9149            len += 1;
9150        }
9151        if self.committed_epoch_limit != 0 {
9152            len += 1;
9153        }
9154        let mut struct_ser = serializer.serialize_struct("hummock.ListVersionDeltasRequest", len)?;
9155        if self.start_id != 0 {
9156            #[allow(clippy::needless_borrow)]
9157            #[allow(clippy::needless_borrows_for_generic_args)]
9158            struct_ser.serialize_field("startId", ToString::to_string(&self.start_id).as_str())?;
9159        }
9160        if self.num_limit != 0 {
9161            struct_ser.serialize_field("numLimit", &self.num_limit)?;
9162        }
9163        if self.committed_epoch_limit != 0 {
9164            #[allow(clippy::needless_borrow)]
9165            #[allow(clippy::needless_borrows_for_generic_args)]
9166            struct_ser.serialize_field("committedEpochLimit", ToString::to_string(&self.committed_epoch_limit).as_str())?;
9167        }
9168        struct_ser.end()
9169    }
9170}
9171impl<'de> serde::Deserialize<'de> for ListVersionDeltasRequest {
9172    #[allow(deprecated)]
9173    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9174    where
9175        D: serde::Deserializer<'de>,
9176    {
9177        const FIELDS: &[&str] = &[
9178            "start_id",
9179            "startId",
9180            "num_limit",
9181            "numLimit",
9182            "committed_epoch_limit",
9183            "committedEpochLimit",
9184        ];
9185
9186        #[allow(clippy::enum_variant_names)]
9187        enum GeneratedField {
9188            StartId,
9189            NumLimit,
9190            CommittedEpochLimit,
9191        }
9192        impl<'de> serde::Deserialize<'de> for GeneratedField {
9193            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9194            where
9195                D: serde::Deserializer<'de>,
9196            {
9197                struct GeneratedVisitor;
9198
9199                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9200                    type Value = GeneratedField;
9201
9202                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9203                        write!(formatter, "expected one of: {:?}", &FIELDS)
9204                    }
9205
9206                    #[allow(unused_variables)]
9207                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9208                    where
9209                        E: serde::de::Error,
9210                    {
9211                        match value {
9212                            "startId" | "start_id" => Ok(GeneratedField::StartId),
9213                            "numLimit" | "num_limit" => Ok(GeneratedField::NumLimit),
9214                            "committedEpochLimit" | "committed_epoch_limit" => Ok(GeneratedField::CommittedEpochLimit),
9215                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9216                        }
9217                    }
9218                }
9219                deserializer.deserialize_identifier(GeneratedVisitor)
9220            }
9221        }
9222        struct GeneratedVisitor;
9223        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9224            type Value = ListVersionDeltasRequest;
9225
9226            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9227                formatter.write_str("struct hummock.ListVersionDeltasRequest")
9228            }
9229
9230            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListVersionDeltasRequest, V::Error>
9231                where
9232                    V: serde::de::MapAccess<'de>,
9233            {
9234                let mut start_id__ = None;
9235                let mut num_limit__ = None;
9236                let mut committed_epoch_limit__ = None;
9237                while let Some(k) = map_.next_key()? {
9238                    match k {
9239                        GeneratedField::StartId => {
9240                            if start_id__.is_some() {
9241                                return Err(serde::de::Error::duplicate_field("startId"));
9242                            }
9243                            start_id__ = 
9244                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9245                            ;
9246                        }
9247                        GeneratedField::NumLimit => {
9248                            if num_limit__.is_some() {
9249                                return Err(serde::de::Error::duplicate_field("numLimit"));
9250                            }
9251                            num_limit__ = 
9252                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9253                            ;
9254                        }
9255                        GeneratedField::CommittedEpochLimit => {
9256                            if committed_epoch_limit__.is_some() {
9257                                return Err(serde::de::Error::duplicate_field("committedEpochLimit"));
9258                            }
9259                            committed_epoch_limit__ = 
9260                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9261                            ;
9262                        }
9263                    }
9264                }
9265                Ok(ListVersionDeltasRequest {
9266                    start_id: start_id__.unwrap_or_default(),
9267                    num_limit: num_limit__.unwrap_or_default(),
9268                    committed_epoch_limit: committed_epoch_limit__.unwrap_or_default(),
9269                })
9270            }
9271        }
9272        deserializer.deserialize_struct("hummock.ListVersionDeltasRequest", FIELDS, GeneratedVisitor)
9273    }
9274}
9275impl serde::Serialize for ListVersionDeltasResponse {
9276    #[allow(deprecated)]
9277    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9278    where
9279        S: serde::Serializer,
9280    {
9281        use serde::ser::SerializeStruct;
9282        let mut len = 0;
9283        if self.version_deltas.is_some() {
9284            len += 1;
9285        }
9286        let mut struct_ser = serializer.serialize_struct("hummock.ListVersionDeltasResponse", len)?;
9287        if let Some(v) = self.version_deltas.as_ref() {
9288            struct_ser.serialize_field("versionDeltas", v)?;
9289        }
9290        struct_ser.end()
9291    }
9292}
9293impl<'de> serde::Deserialize<'de> for ListVersionDeltasResponse {
9294    #[allow(deprecated)]
9295    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9296    where
9297        D: serde::Deserializer<'de>,
9298    {
9299        const FIELDS: &[&str] = &[
9300            "version_deltas",
9301            "versionDeltas",
9302        ];
9303
9304        #[allow(clippy::enum_variant_names)]
9305        enum GeneratedField {
9306            VersionDeltas,
9307        }
9308        impl<'de> serde::Deserialize<'de> for GeneratedField {
9309            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9310            where
9311                D: serde::Deserializer<'de>,
9312            {
9313                struct GeneratedVisitor;
9314
9315                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9316                    type Value = GeneratedField;
9317
9318                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9319                        write!(formatter, "expected one of: {:?}", &FIELDS)
9320                    }
9321
9322                    #[allow(unused_variables)]
9323                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9324                    where
9325                        E: serde::de::Error,
9326                    {
9327                        match value {
9328                            "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
9329                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9330                        }
9331                    }
9332                }
9333                deserializer.deserialize_identifier(GeneratedVisitor)
9334            }
9335        }
9336        struct GeneratedVisitor;
9337        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9338            type Value = ListVersionDeltasResponse;
9339
9340            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9341                formatter.write_str("struct hummock.ListVersionDeltasResponse")
9342            }
9343
9344            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListVersionDeltasResponse, V::Error>
9345                where
9346                    V: serde::de::MapAccess<'de>,
9347            {
9348                let mut version_deltas__ = None;
9349                while let Some(k) = map_.next_key()? {
9350                    match k {
9351                        GeneratedField::VersionDeltas => {
9352                            if version_deltas__.is_some() {
9353                                return Err(serde::de::Error::duplicate_field("versionDeltas"));
9354                            }
9355                            version_deltas__ = map_.next_value()?;
9356                        }
9357                    }
9358                }
9359                Ok(ListVersionDeltasResponse {
9360                    version_deltas: version_deltas__,
9361                })
9362            }
9363        }
9364        deserializer.deserialize_struct("hummock.ListVersionDeltasResponse", FIELDS, GeneratedVisitor)
9365    }
9366}
9367impl serde::Serialize for MergeCompactionGroupRequest {
9368    #[allow(deprecated)]
9369    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9370    where
9371        S: serde::Serializer,
9372    {
9373        use serde::ser::SerializeStruct;
9374        let mut len = 0;
9375        if self.left_group_id != 0 {
9376            len += 1;
9377        }
9378        if self.right_group_id != 0 {
9379            len += 1;
9380        }
9381        let mut struct_ser = serializer.serialize_struct("hummock.MergeCompactionGroupRequest", len)?;
9382        if self.left_group_id != 0 {
9383            #[allow(clippy::needless_borrow)]
9384            #[allow(clippy::needless_borrows_for_generic_args)]
9385            struct_ser.serialize_field("leftGroupId", ToString::to_string(&self.left_group_id).as_str())?;
9386        }
9387        if self.right_group_id != 0 {
9388            #[allow(clippy::needless_borrow)]
9389            #[allow(clippy::needless_borrows_for_generic_args)]
9390            struct_ser.serialize_field("rightGroupId", ToString::to_string(&self.right_group_id).as_str())?;
9391        }
9392        struct_ser.end()
9393    }
9394}
9395impl<'de> serde::Deserialize<'de> for MergeCompactionGroupRequest {
9396    #[allow(deprecated)]
9397    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9398    where
9399        D: serde::Deserializer<'de>,
9400    {
9401        const FIELDS: &[&str] = &[
9402            "left_group_id",
9403            "leftGroupId",
9404            "right_group_id",
9405            "rightGroupId",
9406        ];
9407
9408        #[allow(clippy::enum_variant_names)]
9409        enum GeneratedField {
9410            LeftGroupId,
9411            RightGroupId,
9412        }
9413        impl<'de> serde::Deserialize<'de> for GeneratedField {
9414            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9415            where
9416                D: serde::Deserializer<'de>,
9417            {
9418                struct GeneratedVisitor;
9419
9420                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9421                    type Value = GeneratedField;
9422
9423                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9424                        write!(formatter, "expected one of: {:?}", &FIELDS)
9425                    }
9426
9427                    #[allow(unused_variables)]
9428                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9429                    where
9430                        E: serde::de::Error,
9431                    {
9432                        match value {
9433                            "leftGroupId" | "left_group_id" => Ok(GeneratedField::LeftGroupId),
9434                            "rightGroupId" | "right_group_id" => Ok(GeneratedField::RightGroupId),
9435                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9436                        }
9437                    }
9438                }
9439                deserializer.deserialize_identifier(GeneratedVisitor)
9440            }
9441        }
9442        struct GeneratedVisitor;
9443        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9444            type Value = MergeCompactionGroupRequest;
9445
9446            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9447                formatter.write_str("struct hummock.MergeCompactionGroupRequest")
9448            }
9449
9450            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeCompactionGroupRequest, V::Error>
9451                where
9452                    V: serde::de::MapAccess<'de>,
9453            {
9454                let mut left_group_id__ = None;
9455                let mut right_group_id__ = None;
9456                while let Some(k) = map_.next_key()? {
9457                    match k {
9458                        GeneratedField::LeftGroupId => {
9459                            if left_group_id__.is_some() {
9460                                return Err(serde::de::Error::duplicate_field("leftGroupId"));
9461                            }
9462                            left_group_id__ = 
9463                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9464                            ;
9465                        }
9466                        GeneratedField::RightGroupId => {
9467                            if right_group_id__.is_some() {
9468                                return Err(serde::de::Error::duplicate_field("rightGroupId"));
9469                            }
9470                            right_group_id__ = 
9471                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9472                            ;
9473                        }
9474                    }
9475                }
9476                Ok(MergeCompactionGroupRequest {
9477                    left_group_id: left_group_id__.unwrap_or_default(),
9478                    right_group_id: right_group_id__.unwrap_or_default(),
9479                })
9480            }
9481        }
9482        deserializer.deserialize_struct("hummock.MergeCompactionGroupRequest", FIELDS, GeneratedVisitor)
9483    }
9484}
9485impl serde::Serialize for MergeCompactionGroupResponse {
9486    #[allow(deprecated)]
9487    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9488    where
9489        S: serde::Serializer,
9490    {
9491        use serde::ser::SerializeStruct;
9492        let len = 0;
9493        let struct_ser = serializer.serialize_struct("hummock.MergeCompactionGroupResponse", len)?;
9494        struct_ser.end()
9495    }
9496}
9497impl<'de> serde::Deserialize<'de> for MergeCompactionGroupResponse {
9498    #[allow(deprecated)]
9499    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9500    where
9501        D: serde::Deserializer<'de>,
9502    {
9503        const FIELDS: &[&str] = &[
9504        ];
9505
9506        #[allow(clippy::enum_variant_names)]
9507        enum GeneratedField {
9508        }
9509        impl<'de> serde::Deserialize<'de> for GeneratedField {
9510            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9511            where
9512                D: serde::Deserializer<'de>,
9513            {
9514                struct GeneratedVisitor;
9515
9516                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9517                    type Value = GeneratedField;
9518
9519                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9520                        write!(formatter, "expected one of: {:?}", &FIELDS)
9521                    }
9522
9523                    #[allow(unused_variables)]
9524                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9525                    where
9526                        E: serde::de::Error,
9527                    {
9528                            Err(serde::de::Error::unknown_field(value, FIELDS))
9529                    }
9530                }
9531                deserializer.deserialize_identifier(GeneratedVisitor)
9532            }
9533        }
9534        struct GeneratedVisitor;
9535        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9536            type Value = MergeCompactionGroupResponse;
9537
9538            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9539                formatter.write_str("struct hummock.MergeCompactionGroupResponse")
9540            }
9541
9542            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeCompactionGroupResponse, V::Error>
9543                where
9544                    V: serde::de::MapAccess<'de>,
9545            {
9546                while map_.next_key::<GeneratedField>()?.is_some() {
9547                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9548                }
9549                Ok(MergeCompactionGroupResponse {
9550                })
9551            }
9552        }
9553        deserializer.deserialize_struct("hummock.MergeCompactionGroupResponse", FIELDS, GeneratedVisitor)
9554    }
9555}
9556impl serde::Serialize for NewL0SubLevel {
9557    #[allow(deprecated)]
9558    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9559    where
9560        S: serde::Serializer,
9561    {
9562        use serde::ser::SerializeStruct;
9563        let mut len = 0;
9564        if !self.inserted_table_infos.is_empty() {
9565            len += 1;
9566        }
9567        let mut struct_ser = serializer.serialize_struct("hummock.NewL0SubLevel", len)?;
9568        if !self.inserted_table_infos.is_empty() {
9569            struct_ser.serialize_field("insertedTableInfos", &self.inserted_table_infos)?;
9570        }
9571        struct_ser.end()
9572    }
9573}
9574impl<'de> serde::Deserialize<'de> for NewL0SubLevel {
9575    #[allow(deprecated)]
9576    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9577    where
9578        D: serde::Deserializer<'de>,
9579    {
9580        const FIELDS: &[&str] = &[
9581            "inserted_table_infos",
9582            "insertedTableInfos",
9583        ];
9584
9585        #[allow(clippy::enum_variant_names)]
9586        enum GeneratedField {
9587            InsertedTableInfos,
9588        }
9589        impl<'de> serde::Deserialize<'de> for GeneratedField {
9590            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9591            where
9592                D: serde::Deserializer<'de>,
9593            {
9594                struct GeneratedVisitor;
9595
9596                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9597                    type Value = GeneratedField;
9598
9599                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9600                        write!(formatter, "expected one of: {:?}", &FIELDS)
9601                    }
9602
9603                    #[allow(unused_variables)]
9604                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9605                    where
9606                        E: serde::de::Error,
9607                    {
9608                        match value {
9609                            "insertedTableInfos" | "inserted_table_infos" => Ok(GeneratedField::InsertedTableInfos),
9610                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9611                        }
9612                    }
9613                }
9614                deserializer.deserialize_identifier(GeneratedVisitor)
9615            }
9616        }
9617        struct GeneratedVisitor;
9618        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9619            type Value = NewL0SubLevel;
9620
9621            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9622                formatter.write_str("struct hummock.NewL0SubLevel")
9623            }
9624
9625            fn visit_map<V>(self, mut map_: V) -> std::result::Result<NewL0SubLevel, V::Error>
9626                where
9627                    V: serde::de::MapAccess<'de>,
9628            {
9629                let mut inserted_table_infos__ = None;
9630                while let Some(k) = map_.next_key()? {
9631                    match k {
9632                        GeneratedField::InsertedTableInfos => {
9633                            if inserted_table_infos__.is_some() {
9634                                return Err(serde::de::Error::duplicate_field("insertedTableInfos"));
9635                            }
9636                            inserted_table_infos__ = Some(map_.next_value()?);
9637                        }
9638                    }
9639                }
9640                Ok(NewL0SubLevel {
9641                    inserted_table_infos: inserted_table_infos__.unwrap_or_default(),
9642                })
9643            }
9644        }
9645        deserializer.deserialize_struct("hummock.NewL0SubLevel", FIELDS, GeneratedVisitor)
9646    }
9647}
9648impl serde::Serialize for OverlappingLevel {
9649    #[allow(deprecated)]
9650    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9651    where
9652        S: serde::Serializer,
9653    {
9654        use serde::ser::SerializeStruct;
9655        let mut len = 0;
9656        if !self.sub_levels.is_empty() {
9657            len += 1;
9658        }
9659        if self.total_file_size != 0 {
9660            len += 1;
9661        }
9662        if self.uncompressed_file_size != 0 {
9663            len += 1;
9664        }
9665        let mut struct_ser = serializer.serialize_struct("hummock.OverlappingLevel", len)?;
9666        if !self.sub_levels.is_empty() {
9667            struct_ser.serialize_field("subLevels", &self.sub_levels)?;
9668        }
9669        if self.total_file_size != 0 {
9670            #[allow(clippy::needless_borrow)]
9671            #[allow(clippy::needless_borrows_for_generic_args)]
9672            struct_ser.serialize_field("totalFileSize", ToString::to_string(&self.total_file_size).as_str())?;
9673        }
9674        if self.uncompressed_file_size != 0 {
9675            #[allow(clippy::needless_borrow)]
9676            #[allow(clippy::needless_borrows_for_generic_args)]
9677            struct_ser.serialize_field("uncompressedFileSize", ToString::to_string(&self.uncompressed_file_size).as_str())?;
9678        }
9679        struct_ser.end()
9680    }
9681}
9682impl<'de> serde::Deserialize<'de> for OverlappingLevel {
9683    #[allow(deprecated)]
9684    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9685    where
9686        D: serde::Deserializer<'de>,
9687    {
9688        const FIELDS: &[&str] = &[
9689            "sub_levels",
9690            "subLevels",
9691            "total_file_size",
9692            "totalFileSize",
9693            "uncompressed_file_size",
9694            "uncompressedFileSize",
9695        ];
9696
9697        #[allow(clippy::enum_variant_names)]
9698        enum GeneratedField {
9699            SubLevels,
9700            TotalFileSize,
9701            UncompressedFileSize,
9702        }
9703        impl<'de> serde::Deserialize<'de> for GeneratedField {
9704            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9705            where
9706                D: serde::Deserializer<'de>,
9707            {
9708                struct GeneratedVisitor;
9709
9710                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9711                    type Value = GeneratedField;
9712
9713                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9714                        write!(formatter, "expected one of: {:?}", &FIELDS)
9715                    }
9716
9717                    #[allow(unused_variables)]
9718                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9719                    where
9720                        E: serde::de::Error,
9721                    {
9722                        match value {
9723                            "subLevels" | "sub_levels" => Ok(GeneratedField::SubLevels),
9724                            "totalFileSize" | "total_file_size" => Ok(GeneratedField::TotalFileSize),
9725                            "uncompressedFileSize" | "uncompressed_file_size" => Ok(GeneratedField::UncompressedFileSize),
9726                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9727                        }
9728                    }
9729                }
9730                deserializer.deserialize_identifier(GeneratedVisitor)
9731            }
9732        }
9733        struct GeneratedVisitor;
9734        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9735            type Value = OverlappingLevel;
9736
9737            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9738                formatter.write_str("struct hummock.OverlappingLevel")
9739            }
9740
9741            fn visit_map<V>(self, mut map_: V) -> std::result::Result<OverlappingLevel, V::Error>
9742                where
9743                    V: serde::de::MapAccess<'de>,
9744            {
9745                let mut sub_levels__ = None;
9746                let mut total_file_size__ = None;
9747                let mut uncompressed_file_size__ = None;
9748                while let Some(k) = map_.next_key()? {
9749                    match k {
9750                        GeneratedField::SubLevels => {
9751                            if sub_levels__.is_some() {
9752                                return Err(serde::de::Error::duplicate_field("subLevels"));
9753                            }
9754                            sub_levels__ = Some(map_.next_value()?);
9755                        }
9756                        GeneratedField::TotalFileSize => {
9757                            if total_file_size__.is_some() {
9758                                return Err(serde::de::Error::duplicate_field("totalFileSize"));
9759                            }
9760                            total_file_size__ = 
9761                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9762                            ;
9763                        }
9764                        GeneratedField::UncompressedFileSize => {
9765                            if uncompressed_file_size__.is_some() {
9766                                return Err(serde::de::Error::duplicate_field("uncompressedFileSize"));
9767                            }
9768                            uncompressed_file_size__ = 
9769                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9770                            ;
9771                        }
9772                    }
9773                }
9774                Ok(OverlappingLevel {
9775                    sub_levels: sub_levels__.unwrap_or_default(),
9776                    total_file_size: total_file_size__.unwrap_or_default(),
9777                    uncompressed_file_size: uncompressed_file_size__.unwrap_or_default(),
9778                })
9779            }
9780        }
9781        deserializer.deserialize_struct("hummock.OverlappingLevel", FIELDS, GeneratedVisitor)
9782    }
9783}
9784impl serde::Serialize for PinVersionRequest {
9785    #[allow(deprecated)]
9786    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9787    where
9788        S: serde::Serializer,
9789    {
9790        use serde::ser::SerializeStruct;
9791        let mut len = 0;
9792        if self.context_id != 0 {
9793            len += 1;
9794        }
9795        let mut struct_ser = serializer.serialize_struct("hummock.PinVersionRequest", len)?;
9796        if self.context_id != 0 {
9797            struct_ser.serialize_field("contextId", &self.context_id)?;
9798        }
9799        struct_ser.end()
9800    }
9801}
9802impl<'de> serde::Deserialize<'de> for PinVersionRequest {
9803    #[allow(deprecated)]
9804    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9805    where
9806        D: serde::Deserializer<'de>,
9807    {
9808        const FIELDS: &[&str] = &[
9809            "context_id",
9810            "contextId",
9811        ];
9812
9813        #[allow(clippy::enum_variant_names)]
9814        enum GeneratedField {
9815            ContextId,
9816        }
9817        impl<'de> serde::Deserialize<'de> for GeneratedField {
9818            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9819            where
9820                D: serde::Deserializer<'de>,
9821            {
9822                struct GeneratedVisitor;
9823
9824                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9825                    type Value = GeneratedField;
9826
9827                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9828                        write!(formatter, "expected one of: {:?}", &FIELDS)
9829                    }
9830
9831                    #[allow(unused_variables)]
9832                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9833                    where
9834                        E: serde::de::Error,
9835                    {
9836                        match value {
9837                            "contextId" | "context_id" => Ok(GeneratedField::ContextId),
9838                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9839                        }
9840                    }
9841                }
9842                deserializer.deserialize_identifier(GeneratedVisitor)
9843            }
9844        }
9845        struct GeneratedVisitor;
9846        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9847            type Value = PinVersionRequest;
9848
9849            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9850                formatter.write_str("struct hummock.PinVersionRequest")
9851            }
9852
9853            fn visit_map<V>(self, mut map_: V) -> std::result::Result<PinVersionRequest, V::Error>
9854                where
9855                    V: serde::de::MapAccess<'de>,
9856            {
9857                let mut context_id__ = None;
9858                while let Some(k) = map_.next_key()? {
9859                    match k {
9860                        GeneratedField::ContextId => {
9861                            if context_id__.is_some() {
9862                                return Err(serde::de::Error::duplicate_field("contextId"));
9863                            }
9864                            context_id__ = 
9865                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9866                            ;
9867                        }
9868                    }
9869                }
9870                Ok(PinVersionRequest {
9871                    context_id: context_id__.unwrap_or_default(),
9872                })
9873            }
9874        }
9875        deserializer.deserialize_struct("hummock.PinVersionRequest", FIELDS, GeneratedVisitor)
9876    }
9877}
9878impl serde::Serialize for PinVersionResponse {
9879    #[allow(deprecated)]
9880    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9881    where
9882        S: serde::Serializer,
9883    {
9884        use serde::ser::SerializeStruct;
9885        let mut len = 0;
9886        if self.pinned_version.is_some() {
9887            len += 1;
9888        }
9889        let mut struct_ser = serializer.serialize_struct("hummock.PinVersionResponse", len)?;
9890        if let Some(v) = self.pinned_version.as_ref() {
9891            struct_ser.serialize_field("pinnedVersion", v)?;
9892        }
9893        struct_ser.end()
9894    }
9895}
9896impl<'de> serde::Deserialize<'de> for PinVersionResponse {
9897    #[allow(deprecated)]
9898    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9899    where
9900        D: serde::Deserializer<'de>,
9901    {
9902        const FIELDS: &[&str] = &[
9903            "pinned_version",
9904            "pinnedVersion",
9905        ];
9906
9907        #[allow(clippy::enum_variant_names)]
9908        enum GeneratedField {
9909            PinnedVersion,
9910        }
9911        impl<'de> serde::Deserialize<'de> for GeneratedField {
9912            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9913            where
9914                D: serde::Deserializer<'de>,
9915            {
9916                struct GeneratedVisitor;
9917
9918                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9919                    type Value = GeneratedField;
9920
9921                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9922                        write!(formatter, "expected one of: {:?}", &FIELDS)
9923                    }
9924
9925                    #[allow(unused_variables)]
9926                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9927                    where
9928                        E: serde::de::Error,
9929                    {
9930                        match value {
9931                            "pinnedVersion" | "pinned_version" => Ok(GeneratedField::PinnedVersion),
9932                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9933                        }
9934                    }
9935                }
9936                deserializer.deserialize_identifier(GeneratedVisitor)
9937            }
9938        }
9939        struct GeneratedVisitor;
9940        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9941            type Value = PinVersionResponse;
9942
9943            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9944                formatter.write_str("struct hummock.PinVersionResponse")
9945            }
9946
9947            fn visit_map<V>(self, mut map_: V) -> std::result::Result<PinVersionResponse, V::Error>
9948                where
9949                    V: serde::de::MapAccess<'de>,
9950            {
9951                let mut pinned_version__ = None;
9952                while let Some(k) = map_.next_key()? {
9953                    match k {
9954                        GeneratedField::PinnedVersion => {
9955                            if pinned_version__.is_some() {
9956                                return Err(serde::de::Error::duplicate_field("pinnedVersion"));
9957                            }
9958                            pinned_version__ = map_.next_value()?;
9959                        }
9960                    }
9961                }
9962                Ok(PinVersionResponse {
9963                    pinned_version: pinned_version__,
9964                })
9965            }
9966        }
9967        deserializer.deserialize_struct("hummock.PinVersionResponse", FIELDS, GeneratedVisitor)
9968    }
9969}
9970impl serde::Serialize for PinnedVersionsSummary {
9971    #[allow(deprecated)]
9972    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9973    where
9974        S: serde::Serializer,
9975    {
9976        use serde::ser::SerializeStruct;
9977        let mut len = 0;
9978        if !self.pinned_versions.is_empty() {
9979            len += 1;
9980        }
9981        if !self.workers.is_empty() {
9982            len += 1;
9983        }
9984        let mut struct_ser = serializer.serialize_struct("hummock.PinnedVersionsSummary", len)?;
9985        if !self.pinned_versions.is_empty() {
9986            struct_ser.serialize_field("pinnedVersions", &self.pinned_versions)?;
9987        }
9988        if !self.workers.is_empty() {
9989            struct_ser.serialize_field("workers", &self.workers)?;
9990        }
9991        struct_ser.end()
9992    }
9993}
9994impl<'de> serde::Deserialize<'de> for PinnedVersionsSummary {
9995    #[allow(deprecated)]
9996    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9997    where
9998        D: serde::Deserializer<'de>,
9999    {
10000        const FIELDS: &[&str] = &[
10001            "pinned_versions",
10002            "pinnedVersions",
10003            "workers",
10004        ];
10005
10006        #[allow(clippy::enum_variant_names)]
10007        enum GeneratedField {
10008            PinnedVersions,
10009            Workers,
10010        }
10011        impl<'de> serde::Deserialize<'de> for GeneratedField {
10012            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10013            where
10014                D: serde::Deserializer<'de>,
10015            {
10016                struct GeneratedVisitor;
10017
10018                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10019                    type Value = GeneratedField;
10020
10021                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10022                        write!(formatter, "expected one of: {:?}", &FIELDS)
10023                    }
10024
10025                    #[allow(unused_variables)]
10026                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10027                    where
10028                        E: serde::de::Error,
10029                    {
10030                        match value {
10031                            "pinnedVersions" | "pinned_versions" => Ok(GeneratedField::PinnedVersions),
10032                            "workers" => Ok(GeneratedField::Workers),
10033                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10034                        }
10035                    }
10036                }
10037                deserializer.deserialize_identifier(GeneratedVisitor)
10038            }
10039        }
10040        struct GeneratedVisitor;
10041        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10042            type Value = PinnedVersionsSummary;
10043
10044            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10045                formatter.write_str("struct hummock.PinnedVersionsSummary")
10046            }
10047
10048            fn visit_map<V>(self, mut map_: V) -> std::result::Result<PinnedVersionsSummary, V::Error>
10049                where
10050                    V: serde::de::MapAccess<'de>,
10051            {
10052                let mut pinned_versions__ = None;
10053                let mut workers__ = None;
10054                while let Some(k) = map_.next_key()? {
10055                    match k {
10056                        GeneratedField::PinnedVersions => {
10057                            if pinned_versions__.is_some() {
10058                                return Err(serde::de::Error::duplicate_field("pinnedVersions"));
10059                            }
10060                            pinned_versions__ = Some(map_.next_value()?);
10061                        }
10062                        GeneratedField::Workers => {
10063                            if workers__.is_some() {
10064                                return Err(serde::de::Error::duplicate_field("workers"));
10065                            }
10066                            workers__ = Some(
10067                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
10068                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
10069                            );
10070                        }
10071                    }
10072                }
10073                Ok(PinnedVersionsSummary {
10074                    pinned_versions: pinned_versions__.unwrap_or_default(),
10075                    workers: workers__.unwrap_or_default(),
10076                })
10077            }
10078        }
10079        deserializer.deserialize_struct("hummock.PinnedVersionsSummary", FIELDS, GeneratedVisitor)
10080    }
10081}
10082impl serde::Serialize for ReplayVersionDeltaRequest {
10083    #[allow(deprecated)]
10084    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10085    where
10086        S: serde::Serializer,
10087    {
10088        use serde::ser::SerializeStruct;
10089        let mut len = 0;
10090        if self.version_delta.is_some() {
10091            len += 1;
10092        }
10093        let mut struct_ser = serializer.serialize_struct("hummock.ReplayVersionDeltaRequest", len)?;
10094        if let Some(v) = self.version_delta.as_ref() {
10095            struct_ser.serialize_field("versionDelta", v)?;
10096        }
10097        struct_ser.end()
10098    }
10099}
10100impl<'de> serde::Deserialize<'de> for ReplayVersionDeltaRequest {
10101    #[allow(deprecated)]
10102    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10103    where
10104        D: serde::Deserializer<'de>,
10105    {
10106        const FIELDS: &[&str] = &[
10107            "version_delta",
10108            "versionDelta",
10109        ];
10110
10111        #[allow(clippy::enum_variant_names)]
10112        enum GeneratedField {
10113            VersionDelta,
10114        }
10115        impl<'de> serde::Deserialize<'de> for GeneratedField {
10116            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10117            where
10118                D: serde::Deserializer<'de>,
10119            {
10120                struct GeneratedVisitor;
10121
10122                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10123                    type Value = GeneratedField;
10124
10125                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10126                        write!(formatter, "expected one of: {:?}", &FIELDS)
10127                    }
10128
10129                    #[allow(unused_variables)]
10130                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10131                    where
10132                        E: serde::de::Error,
10133                    {
10134                        match value {
10135                            "versionDelta" | "version_delta" => Ok(GeneratedField::VersionDelta),
10136                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10137                        }
10138                    }
10139                }
10140                deserializer.deserialize_identifier(GeneratedVisitor)
10141            }
10142        }
10143        struct GeneratedVisitor;
10144        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10145            type Value = ReplayVersionDeltaRequest;
10146
10147            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10148                formatter.write_str("struct hummock.ReplayVersionDeltaRequest")
10149            }
10150
10151            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplayVersionDeltaRequest, V::Error>
10152                where
10153                    V: serde::de::MapAccess<'de>,
10154            {
10155                let mut version_delta__ = None;
10156                while let Some(k) = map_.next_key()? {
10157                    match k {
10158                        GeneratedField::VersionDelta => {
10159                            if version_delta__.is_some() {
10160                                return Err(serde::de::Error::duplicate_field("versionDelta"));
10161                            }
10162                            version_delta__ = map_.next_value()?;
10163                        }
10164                    }
10165                }
10166                Ok(ReplayVersionDeltaRequest {
10167                    version_delta: version_delta__,
10168                })
10169            }
10170        }
10171        deserializer.deserialize_struct("hummock.ReplayVersionDeltaRequest", FIELDS, GeneratedVisitor)
10172    }
10173}
10174impl serde::Serialize for ReplayVersionDeltaResponse {
10175    #[allow(deprecated)]
10176    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10177    where
10178        S: serde::Serializer,
10179    {
10180        use serde::ser::SerializeStruct;
10181        let mut len = 0;
10182        if self.version.is_some() {
10183            len += 1;
10184        }
10185        if !self.modified_compaction_groups.is_empty() {
10186            len += 1;
10187        }
10188        let mut struct_ser = serializer.serialize_struct("hummock.ReplayVersionDeltaResponse", len)?;
10189        if let Some(v) = self.version.as_ref() {
10190            struct_ser.serialize_field("version", v)?;
10191        }
10192        if !self.modified_compaction_groups.is_empty() {
10193            struct_ser.serialize_field("modifiedCompactionGroups", &self.modified_compaction_groups.iter().map(ToString::to_string).collect::<Vec<_>>())?;
10194        }
10195        struct_ser.end()
10196    }
10197}
10198impl<'de> serde::Deserialize<'de> for ReplayVersionDeltaResponse {
10199    #[allow(deprecated)]
10200    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10201    where
10202        D: serde::Deserializer<'de>,
10203    {
10204        const FIELDS: &[&str] = &[
10205            "version",
10206            "modified_compaction_groups",
10207            "modifiedCompactionGroups",
10208        ];
10209
10210        #[allow(clippy::enum_variant_names)]
10211        enum GeneratedField {
10212            Version,
10213            ModifiedCompactionGroups,
10214        }
10215        impl<'de> serde::Deserialize<'de> for GeneratedField {
10216            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10217            where
10218                D: serde::Deserializer<'de>,
10219            {
10220                struct GeneratedVisitor;
10221
10222                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10223                    type Value = GeneratedField;
10224
10225                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10226                        write!(formatter, "expected one of: {:?}", &FIELDS)
10227                    }
10228
10229                    #[allow(unused_variables)]
10230                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10231                    where
10232                        E: serde::de::Error,
10233                    {
10234                        match value {
10235                            "version" => Ok(GeneratedField::Version),
10236                            "modifiedCompactionGroups" | "modified_compaction_groups" => Ok(GeneratedField::ModifiedCompactionGroups),
10237                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10238                        }
10239                    }
10240                }
10241                deserializer.deserialize_identifier(GeneratedVisitor)
10242            }
10243        }
10244        struct GeneratedVisitor;
10245        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10246            type Value = ReplayVersionDeltaResponse;
10247
10248            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10249                formatter.write_str("struct hummock.ReplayVersionDeltaResponse")
10250            }
10251
10252            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReplayVersionDeltaResponse, V::Error>
10253                where
10254                    V: serde::de::MapAccess<'de>,
10255            {
10256                let mut version__ = None;
10257                let mut modified_compaction_groups__ = None;
10258                while let Some(k) = map_.next_key()? {
10259                    match k {
10260                        GeneratedField::Version => {
10261                            if version__.is_some() {
10262                                return Err(serde::de::Error::duplicate_field("version"));
10263                            }
10264                            version__ = map_.next_value()?;
10265                        }
10266                        GeneratedField::ModifiedCompactionGroups => {
10267                            if modified_compaction_groups__.is_some() {
10268                                return Err(serde::de::Error::duplicate_field("modifiedCompactionGroups"));
10269                            }
10270                            modified_compaction_groups__ = 
10271                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10272                                    .into_iter().map(|x| x.0).collect())
10273                            ;
10274                        }
10275                    }
10276                }
10277                Ok(ReplayVersionDeltaResponse {
10278                    version: version__,
10279                    modified_compaction_groups: modified_compaction_groups__.unwrap_or_default(),
10280                })
10281            }
10282        }
10283        deserializer.deserialize_struct("hummock.ReplayVersionDeltaResponse", FIELDS, GeneratedVisitor)
10284    }
10285}
10286impl serde::Serialize for ReportCompactionTaskRequest {
10287    #[allow(deprecated)]
10288    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10289    where
10290        S: serde::Serializer,
10291    {
10292        use serde::ser::SerializeStruct;
10293        let mut len = 0;
10294        if self.event.is_some() {
10295            len += 1;
10296        }
10297        let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskRequest", len)?;
10298        if let Some(v) = self.event.as_ref() {
10299            match v {
10300                report_compaction_task_request::Event::ReportTask(v) => {
10301                    struct_ser.serialize_field("reportTask", v)?;
10302                }
10303                report_compaction_task_request::Event::HeartBeat(v) => {
10304                    struct_ser.serialize_field("heartBeat", v)?;
10305                }
10306            }
10307        }
10308        struct_ser.end()
10309    }
10310}
10311impl<'de> serde::Deserialize<'de> for ReportCompactionTaskRequest {
10312    #[allow(deprecated)]
10313    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10314    where
10315        D: serde::Deserializer<'de>,
10316    {
10317        const FIELDS: &[&str] = &[
10318            "report_task",
10319            "reportTask",
10320            "heart_beat",
10321            "heartBeat",
10322        ];
10323
10324        #[allow(clippy::enum_variant_names)]
10325        enum GeneratedField {
10326            ReportTask,
10327            HeartBeat,
10328        }
10329        impl<'de> serde::Deserialize<'de> for GeneratedField {
10330            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10331            where
10332                D: serde::Deserializer<'de>,
10333            {
10334                struct GeneratedVisitor;
10335
10336                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10337                    type Value = GeneratedField;
10338
10339                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10340                        write!(formatter, "expected one of: {:?}", &FIELDS)
10341                    }
10342
10343                    #[allow(unused_variables)]
10344                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10345                    where
10346                        E: serde::de::Error,
10347                    {
10348                        match value {
10349                            "reportTask" | "report_task" => Ok(GeneratedField::ReportTask),
10350                            "heartBeat" | "heart_beat" => Ok(GeneratedField::HeartBeat),
10351                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10352                        }
10353                    }
10354                }
10355                deserializer.deserialize_identifier(GeneratedVisitor)
10356            }
10357        }
10358        struct GeneratedVisitor;
10359        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10360            type Value = ReportCompactionTaskRequest;
10361
10362            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10363                formatter.write_str("struct hummock.ReportCompactionTaskRequest")
10364            }
10365
10366            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReportCompactionTaskRequest, V::Error>
10367                where
10368                    V: serde::de::MapAccess<'de>,
10369            {
10370                let mut event__ = None;
10371                while let Some(k) = map_.next_key()? {
10372                    match k {
10373                        GeneratedField::ReportTask => {
10374                            if event__.is_some() {
10375                                return Err(serde::de::Error::duplicate_field("reportTask"));
10376                            }
10377                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(report_compaction_task_request::Event::ReportTask)
10378;
10379                        }
10380                        GeneratedField::HeartBeat => {
10381                            if event__.is_some() {
10382                                return Err(serde::de::Error::duplicate_field("heartBeat"));
10383                            }
10384                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(report_compaction_task_request::Event::HeartBeat)
10385;
10386                        }
10387                    }
10388                }
10389                Ok(ReportCompactionTaskRequest {
10390                    event: event__,
10391                })
10392            }
10393        }
10394        deserializer.deserialize_struct("hummock.ReportCompactionTaskRequest", FIELDS, GeneratedVisitor)
10395    }
10396}
10397impl serde::Serialize for report_compaction_task_request::HeartBeat {
10398    #[allow(deprecated)]
10399    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10400    where
10401        S: serde::Serializer,
10402    {
10403        use serde::ser::SerializeStruct;
10404        let mut len = 0;
10405        if !self.progress.is_empty() {
10406            len += 1;
10407        }
10408        let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskRequest.HeartBeat", len)?;
10409        if !self.progress.is_empty() {
10410            struct_ser.serialize_field("progress", &self.progress)?;
10411        }
10412        struct_ser.end()
10413    }
10414}
10415impl<'de> serde::Deserialize<'de> for report_compaction_task_request::HeartBeat {
10416    #[allow(deprecated)]
10417    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10418    where
10419        D: serde::Deserializer<'de>,
10420    {
10421        const FIELDS: &[&str] = &[
10422            "progress",
10423        ];
10424
10425        #[allow(clippy::enum_variant_names)]
10426        enum GeneratedField {
10427            Progress,
10428        }
10429        impl<'de> serde::Deserialize<'de> for GeneratedField {
10430            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10431            where
10432                D: serde::Deserializer<'de>,
10433            {
10434                struct GeneratedVisitor;
10435
10436                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10437                    type Value = GeneratedField;
10438
10439                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10440                        write!(formatter, "expected one of: {:?}", &FIELDS)
10441                    }
10442
10443                    #[allow(unused_variables)]
10444                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10445                    where
10446                        E: serde::de::Error,
10447                    {
10448                        match value {
10449                            "progress" => Ok(GeneratedField::Progress),
10450                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10451                        }
10452                    }
10453                }
10454                deserializer.deserialize_identifier(GeneratedVisitor)
10455            }
10456        }
10457        struct GeneratedVisitor;
10458        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10459            type Value = report_compaction_task_request::HeartBeat;
10460
10461            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10462                formatter.write_str("struct hummock.ReportCompactionTaskRequest.HeartBeat")
10463            }
10464
10465            fn visit_map<V>(self, mut map_: V) -> std::result::Result<report_compaction_task_request::HeartBeat, V::Error>
10466                where
10467                    V: serde::de::MapAccess<'de>,
10468            {
10469                let mut progress__ = None;
10470                while let Some(k) = map_.next_key()? {
10471                    match k {
10472                        GeneratedField::Progress => {
10473                            if progress__.is_some() {
10474                                return Err(serde::de::Error::duplicate_field("progress"));
10475                            }
10476                            progress__ = Some(map_.next_value()?);
10477                        }
10478                    }
10479                }
10480                Ok(report_compaction_task_request::HeartBeat {
10481                    progress: progress__.unwrap_or_default(),
10482                })
10483            }
10484        }
10485        deserializer.deserialize_struct("hummock.ReportCompactionTaskRequest.HeartBeat", FIELDS, GeneratedVisitor)
10486    }
10487}
10488impl serde::Serialize for report_compaction_task_request::ReportTask {
10489    #[allow(deprecated)]
10490    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10491    where
10492        S: serde::Serializer,
10493    {
10494        use serde::ser::SerializeStruct;
10495        let mut len = 0;
10496        if self.compact_task.is_some() {
10497            len += 1;
10498        }
10499        if !self.table_stats_change.is_empty() {
10500            len += 1;
10501        }
10502        if !self.object_timestamps.is_empty() {
10503            len += 1;
10504        }
10505        let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskRequest.ReportTask", len)?;
10506        if let Some(v) = self.compact_task.as_ref() {
10507            struct_ser.serialize_field("compactTask", v)?;
10508        }
10509        if !self.table_stats_change.is_empty() {
10510            struct_ser.serialize_field("tableStatsChange", &self.table_stats_change)?;
10511        }
10512        if !self.object_timestamps.is_empty() {
10513            let v: std::collections::HashMap<_, _> = self.object_timestamps.iter()
10514                .map(|(k, v)| (k, v.to_string())).collect();
10515            struct_ser.serialize_field("objectTimestamps", &v)?;
10516        }
10517        struct_ser.end()
10518    }
10519}
10520impl<'de> serde::Deserialize<'de> for report_compaction_task_request::ReportTask {
10521    #[allow(deprecated)]
10522    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10523    where
10524        D: serde::Deserializer<'de>,
10525    {
10526        const FIELDS: &[&str] = &[
10527            "compact_task",
10528            "compactTask",
10529            "table_stats_change",
10530            "tableStatsChange",
10531            "object_timestamps",
10532            "objectTimestamps",
10533        ];
10534
10535        #[allow(clippy::enum_variant_names)]
10536        enum GeneratedField {
10537            CompactTask,
10538            TableStatsChange,
10539            ObjectTimestamps,
10540        }
10541        impl<'de> serde::Deserialize<'de> for GeneratedField {
10542            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10543            where
10544                D: serde::Deserializer<'de>,
10545            {
10546                struct GeneratedVisitor;
10547
10548                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10549                    type Value = GeneratedField;
10550
10551                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10552                        write!(formatter, "expected one of: {:?}", &FIELDS)
10553                    }
10554
10555                    #[allow(unused_variables)]
10556                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10557                    where
10558                        E: serde::de::Error,
10559                    {
10560                        match value {
10561                            "compactTask" | "compact_task" => Ok(GeneratedField::CompactTask),
10562                            "tableStatsChange" | "table_stats_change" => Ok(GeneratedField::TableStatsChange),
10563                            "objectTimestamps" | "object_timestamps" => Ok(GeneratedField::ObjectTimestamps),
10564                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10565                        }
10566                    }
10567                }
10568                deserializer.deserialize_identifier(GeneratedVisitor)
10569            }
10570        }
10571        struct GeneratedVisitor;
10572        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10573            type Value = report_compaction_task_request::ReportTask;
10574
10575            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10576                formatter.write_str("struct hummock.ReportCompactionTaskRequest.ReportTask")
10577            }
10578
10579            fn visit_map<V>(self, mut map_: V) -> std::result::Result<report_compaction_task_request::ReportTask, V::Error>
10580                where
10581                    V: serde::de::MapAccess<'de>,
10582            {
10583                let mut compact_task__ = None;
10584                let mut table_stats_change__ = None;
10585                let mut object_timestamps__ = None;
10586                while let Some(k) = map_.next_key()? {
10587                    match k {
10588                        GeneratedField::CompactTask => {
10589                            if compact_task__.is_some() {
10590                                return Err(serde::de::Error::duplicate_field("compactTask"));
10591                            }
10592                            compact_task__ = map_.next_value()?;
10593                        }
10594                        GeneratedField::TableStatsChange => {
10595                            if table_stats_change__.is_some() {
10596                                return Err(serde::de::Error::duplicate_field("tableStatsChange"));
10597                            }
10598                            table_stats_change__ = Some(
10599                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
10600                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
10601                            );
10602                        }
10603                        GeneratedField::ObjectTimestamps => {
10604                            if object_timestamps__.is_some() {
10605                                return Err(serde::de::Error::duplicate_field("objectTimestamps"));
10606                            }
10607                            object_timestamps__ = Some(
10608                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
10609                                    .into_iter().map(|(k,v)| (k.0, v.0)).collect()
10610                            );
10611                        }
10612                    }
10613                }
10614                Ok(report_compaction_task_request::ReportTask {
10615                    compact_task: compact_task__,
10616                    table_stats_change: table_stats_change__.unwrap_or_default(),
10617                    object_timestamps: object_timestamps__.unwrap_or_default(),
10618                })
10619            }
10620        }
10621        deserializer.deserialize_struct("hummock.ReportCompactionTaskRequest.ReportTask", FIELDS, GeneratedVisitor)
10622    }
10623}
10624impl serde::Serialize for ReportCompactionTaskResponse {
10625    #[allow(deprecated)]
10626    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10627    where
10628        S: serde::Serializer,
10629    {
10630        use serde::ser::SerializeStruct;
10631        let mut len = 0;
10632        if self.status.is_some() {
10633            len += 1;
10634        }
10635        let mut struct_ser = serializer.serialize_struct("hummock.ReportCompactionTaskResponse", len)?;
10636        if let Some(v) = self.status.as_ref() {
10637            struct_ser.serialize_field("status", v)?;
10638        }
10639        struct_ser.end()
10640    }
10641}
10642impl<'de> serde::Deserialize<'de> for ReportCompactionTaskResponse {
10643    #[allow(deprecated)]
10644    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10645    where
10646        D: serde::Deserializer<'de>,
10647    {
10648        const FIELDS: &[&str] = &[
10649            "status",
10650        ];
10651
10652        #[allow(clippy::enum_variant_names)]
10653        enum GeneratedField {
10654            Status,
10655        }
10656        impl<'de> serde::Deserialize<'de> for GeneratedField {
10657            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10658            where
10659                D: serde::Deserializer<'de>,
10660            {
10661                struct GeneratedVisitor;
10662
10663                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10664                    type Value = GeneratedField;
10665
10666                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10667                        write!(formatter, "expected one of: {:?}", &FIELDS)
10668                    }
10669
10670                    #[allow(unused_variables)]
10671                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10672                    where
10673                        E: serde::de::Error,
10674                    {
10675                        match value {
10676                            "status" => Ok(GeneratedField::Status),
10677                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10678                        }
10679                    }
10680                }
10681                deserializer.deserialize_identifier(GeneratedVisitor)
10682            }
10683        }
10684        struct GeneratedVisitor;
10685        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10686            type Value = ReportCompactionTaskResponse;
10687
10688            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10689                formatter.write_str("struct hummock.ReportCompactionTaskResponse")
10690            }
10691
10692            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReportCompactionTaskResponse, V::Error>
10693                where
10694                    V: serde::de::MapAccess<'de>,
10695            {
10696                let mut status__ = None;
10697                while let Some(k) = map_.next_key()? {
10698                    match k {
10699                        GeneratedField::Status => {
10700                            if status__.is_some() {
10701                                return Err(serde::de::Error::duplicate_field("status"));
10702                            }
10703                            status__ = map_.next_value()?;
10704                        }
10705                    }
10706                }
10707                Ok(ReportCompactionTaskResponse {
10708                    status: status__,
10709                })
10710            }
10711        }
10712        deserializer.deserialize_struct("hummock.ReportCompactionTaskResponse", FIELDS, GeneratedVisitor)
10713    }
10714}
10715impl serde::Serialize for RiseCtlGetCheckpointVersionRequest {
10716    #[allow(deprecated)]
10717    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10718    where
10719        S: serde::Serializer,
10720    {
10721        use serde::ser::SerializeStruct;
10722        let len = 0;
10723        let struct_ser = serializer.serialize_struct("hummock.RiseCtlGetCheckpointVersionRequest", len)?;
10724        struct_ser.end()
10725    }
10726}
10727impl<'de> serde::Deserialize<'de> for RiseCtlGetCheckpointVersionRequest {
10728    #[allow(deprecated)]
10729    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10730    where
10731        D: serde::Deserializer<'de>,
10732    {
10733        const FIELDS: &[&str] = &[
10734        ];
10735
10736        #[allow(clippy::enum_variant_names)]
10737        enum GeneratedField {
10738        }
10739        impl<'de> serde::Deserialize<'de> for GeneratedField {
10740            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10741            where
10742                D: serde::Deserializer<'de>,
10743            {
10744                struct GeneratedVisitor;
10745
10746                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10747                    type Value = GeneratedField;
10748
10749                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10750                        write!(formatter, "expected one of: {:?}", &FIELDS)
10751                    }
10752
10753                    #[allow(unused_variables)]
10754                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10755                    where
10756                        E: serde::de::Error,
10757                    {
10758                            Err(serde::de::Error::unknown_field(value, FIELDS))
10759                    }
10760                }
10761                deserializer.deserialize_identifier(GeneratedVisitor)
10762            }
10763        }
10764        struct GeneratedVisitor;
10765        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10766            type Value = RiseCtlGetCheckpointVersionRequest;
10767
10768            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10769                formatter.write_str("struct hummock.RiseCtlGetCheckpointVersionRequest")
10770            }
10771
10772            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetCheckpointVersionRequest, V::Error>
10773                where
10774                    V: serde::de::MapAccess<'de>,
10775            {
10776                while map_.next_key::<GeneratedField>()?.is_some() {
10777                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10778                }
10779                Ok(RiseCtlGetCheckpointVersionRequest {
10780                })
10781            }
10782        }
10783        deserializer.deserialize_struct("hummock.RiseCtlGetCheckpointVersionRequest", FIELDS, GeneratedVisitor)
10784    }
10785}
10786impl serde::Serialize for RiseCtlGetCheckpointVersionResponse {
10787    #[allow(deprecated)]
10788    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10789    where
10790        S: serde::Serializer,
10791    {
10792        use serde::ser::SerializeStruct;
10793        let mut len = 0;
10794        if self.checkpoint_version.is_some() {
10795            len += 1;
10796        }
10797        let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlGetCheckpointVersionResponse", len)?;
10798        if let Some(v) = self.checkpoint_version.as_ref() {
10799            struct_ser.serialize_field("checkpointVersion", v)?;
10800        }
10801        struct_ser.end()
10802    }
10803}
10804impl<'de> serde::Deserialize<'de> for RiseCtlGetCheckpointVersionResponse {
10805    #[allow(deprecated)]
10806    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10807    where
10808        D: serde::Deserializer<'de>,
10809    {
10810        const FIELDS: &[&str] = &[
10811            "checkpoint_version",
10812            "checkpointVersion",
10813        ];
10814
10815        #[allow(clippy::enum_variant_names)]
10816        enum GeneratedField {
10817            CheckpointVersion,
10818        }
10819        impl<'de> serde::Deserialize<'de> for GeneratedField {
10820            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10821            where
10822                D: serde::Deserializer<'de>,
10823            {
10824                struct GeneratedVisitor;
10825
10826                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10827                    type Value = GeneratedField;
10828
10829                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10830                        write!(formatter, "expected one of: {:?}", &FIELDS)
10831                    }
10832
10833                    #[allow(unused_variables)]
10834                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10835                    where
10836                        E: serde::de::Error,
10837                    {
10838                        match value {
10839                            "checkpointVersion" | "checkpoint_version" => Ok(GeneratedField::CheckpointVersion),
10840                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10841                        }
10842                    }
10843                }
10844                deserializer.deserialize_identifier(GeneratedVisitor)
10845            }
10846        }
10847        struct GeneratedVisitor;
10848        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10849            type Value = RiseCtlGetCheckpointVersionResponse;
10850
10851            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10852                formatter.write_str("struct hummock.RiseCtlGetCheckpointVersionResponse")
10853            }
10854
10855            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetCheckpointVersionResponse, V::Error>
10856                where
10857                    V: serde::de::MapAccess<'de>,
10858            {
10859                let mut checkpoint_version__ = None;
10860                while let Some(k) = map_.next_key()? {
10861                    match k {
10862                        GeneratedField::CheckpointVersion => {
10863                            if checkpoint_version__.is_some() {
10864                                return Err(serde::de::Error::duplicate_field("checkpointVersion"));
10865                            }
10866                            checkpoint_version__ = map_.next_value()?;
10867                        }
10868                    }
10869                }
10870                Ok(RiseCtlGetCheckpointVersionResponse {
10871                    checkpoint_version: checkpoint_version__,
10872                })
10873            }
10874        }
10875        deserializer.deserialize_struct("hummock.RiseCtlGetCheckpointVersionResponse", FIELDS, GeneratedVisitor)
10876    }
10877}
10878impl serde::Serialize for RiseCtlGetPinnedVersionsSummaryRequest {
10879    #[allow(deprecated)]
10880    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10881    where
10882        S: serde::Serializer,
10883    {
10884        use serde::ser::SerializeStruct;
10885        let len = 0;
10886        let struct_ser = serializer.serialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryRequest", len)?;
10887        struct_ser.end()
10888    }
10889}
10890impl<'de> serde::Deserialize<'de> for RiseCtlGetPinnedVersionsSummaryRequest {
10891    #[allow(deprecated)]
10892    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10893    where
10894        D: serde::Deserializer<'de>,
10895    {
10896        const FIELDS: &[&str] = &[
10897        ];
10898
10899        #[allow(clippy::enum_variant_names)]
10900        enum GeneratedField {
10901        }
10902        impl<'de> serde::Deserialize<'de> for GeneratedField {
10903            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10904            where
10905                D: serde::Deserializer<'de>,
10906            {
10907                struct GeneratedVisitor;
10908
10909                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10910                    type Value = GeneratedField;
10911
10912                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10913                        write!(formatter, "expected one of: {:?}", &FIELDS)
10914                    }
10915
10916                    #[allow(unused_variables)]
10917                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10918                    where
10919                        E: serde::de::Error,
10920                    {
10921                            Err(serde::de::Error::unknown_field(value, FIELDS))
10922                    }
10923                }
10924                deserializer.deserialize_identifier(GeneratedVisitor)
10925            }
10926        }
10927        struct GeneratedVisitor;
10928        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10929            type Value = RiseCtlGetPinnedVersionsSummaryRequest;
10930
10931            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10932                formatter.write_str("struct hummock.RiseCtlGetPinnedVersionsSummaryRequest")
10933            }
10934
10935            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetPinnedVersionsSummaryRequest, V::Error>
10936                where
10937                    V: serde::de::MapAccess<'de>,
10938            {
10939                while map_.next_key::<GeneratedField>()?.is_some() {
10940                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10941                }
10942                Ok(RiseCtlGetPinnedVersionsSummaryRequest {
10943                })
10944            }
10945        }
10946        deserializer.deserialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryRequest", FIELDS, GeneratedVisitor)
10947    }
10948}
10949impl serde::Serialize for RiseCtlGetPinnedVersionsSummaryResponse {
10950    #[allow(deprecated)]
10951    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10952    where
10953        S: serde::Serializer,
10954    {
10955        use serde::ser::SerializeStruct;
10956        let mut len = 0;
10957        if self.summary.is_some() {
10958            len += 1;
10959        }
10960        let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryResponse", len)?;
10961        if let Some(v) = self.summary.as_ref() {
10962            struct_ser.serialize_field("summary", v)?;
10963        }
10964        struct_ser.end()
10965    }
10966}
10967impl<'de> serde::Deserialize<'de> for RiseCtlGetPinnedVersionsSummaryResponse {
10968    #[allow(deprecated)]
10969    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10970    where
10971        D: serde::Deserializer<'de>,
10972    {
10973        const FIELDS: &[&str] = &[
10974            "summary",
10975        ];
10976
10977        #[allow(clippy::enum_variant_names)]
10978        enum GeneratedField {
10979            Summary,
10980        }
10981        impl<'de> serde::Deserialize<'de> for GeneratedField {
10982            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10983            where
10984                D: serde::Deserializer<'de>,
10985            {
10986                struct GeneratedVisitor;
10987
10988                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10989                    type Value = GeneratedField;
10990
10991                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10992                        write!(formatter, "expected one of: {:?}", &FIELDS)
10993                    }
10994
10995                    #[allow(unused_variables)]
10996                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10997                    where
10998                        E: serde::de::Error,
10999                    {
11000                        match value {
11001                            "summary" => Ok(GeneratedField::Summary),
11002                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11003                        }
11004                    }
11005                }
11006                deserializer.deserialize_identifier(GeneratedVisitor)
11007            }
11008        }
11009        struct GeneratedVisitor;
11010        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11011            type Value = RiseCtlGetPinnedVersionsSummaryResponse;
11012
11013            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11014                formatter.write_str("struct hummock.RiseCtlGetPinnedVersionsSummaryResponse")
11015            }
11016
11017            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlGetPinnedVersionsSummaryResponse, V::Error>
11018                where
11019                    V: serde::de::MapAccess<'de>,
11020            {
11021                let mut summary__ = None;
11022                while let Some(k) = map_.next_key()? {
11023                    match k {
11024                        GeneratedField::Summary => {
11025                            if summary__.is_some() {
11026                                return Err(serde::de::Error::duplicate_field("summary"));
11027                            }
11028                            summary__ = map_.next_value()?;
11029                        }
11030                    }
11031                }
11032                Ok(RiseCtlGetPinnedVersionsSummaryResponse {
11033                    summary: summary__,
11034                })
11035            }
11036        }
11037        deserializer.deserialize_struct("hummock.RiseCtlGetPinnedVersionsSummaryResponse", FIELDS, GeneratedVisitor)
11038    }
11039}
11040impl serde::Serialize for RiseCtlListCompactionGroupRequest {
11041    #[allow(deprecated)]
11042    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11043    where
11044        S: serde::Serializer,
11045    {
11046        use serde::ser::SerializeStruct;
11047        let len = 0;
11048        let struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionGroupRequest", len)?;
11049        struct_ser.end()
11050    }
11051}
11052impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionGroupRequest {
11053    #[allow(deprecated)]
11054    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11055    where
11056        D: serde::Deserializer<'de>,
11057    {
11058        const FIELDS: &[&str] = &[
11059        ];
11060
11061        #[allow(clippy::enum_variant_names)]
11062        enum GeneratedField {
11063        }
11064        impl<'de> serde::Deserialize<'de> for GeneratedField {
11065            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11066            where
11067                D: serde::Deserializer<'de>,
11068            {
11069                struct GeneratedVisitor;
11070
11071                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11072                    type Value = GeneratedField;
11073
11074                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11075                        write!(formatter, "expected one of: {:?}", &FIELDS)
11076                    }
11077
11078                    #[allow(unused_variables)]
11079                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11080                    where
11081                        E: serde::de::Error,
11082                    {
11083                            Err(serde::de::Error::unknown_field(value, FIELDS))
11084                    }
11085                }
11086                deserializer.deserialize_identifier(GeneratedVisitor)
11087            }
11088        }
11089        struct GeneratedVisitor;
11090        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11091            type Value = RiseCtlListCompactionGroupRequest;
11092
11093            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11094                formatter.write_str("struct hummock.RiseCtlListCompactionGroupRequest")
11095            }
11096
11097            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionGroupRequest, V::Error>
11098                where
11099                    V: serde::de::MapAccess<'de>,
11100            {
11101                while map_.next_key::<GeneratedField>()?.is_some() {
11102                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11103                }
11104                Ok(RiseCtlListCompactionGroupRequest {
11105                })
11106            }
11107        }
11108        deserializer.deserialize_struct("hummock.RiseCtlListCompactionGroupRequest", FIELDS, GeneratedVisitor)
11109    }
11110}
11111impl serde::Serialize for RiseCtlListCompactionGroupResponse {
11112    #[allow(deprecated)]
11113    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11114    where
11115        S: serde::Serializer,
11116    {
11117        use serde::ser::SerializeStruct;
11118        let mut len = 0;
11119        if self.status.is_some() {
11120            len += 1;
11121        }
11122        if !self.compaction_groups.is_empty() {
11123            len += 1;
11124        }
11125        let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionGroupResponse", len)?;
11126        if let Some(v) = self.status.as_ref() {
11127            struct_ser.serialize_field("status", v)?;
11128        }
11129        if !self.compaction_groups.is_empty() {
11130            struct_ser.serialize_field("compactionGroups", &self.compaction_groups)?;
11131        }
11132        struct_ser.end()
11133    }
11134}
11135impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionGroupResponse {
11136    #[allow(deprecated)]
11137    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11138    where
11139        D: serde::Deserializer<'de>,
11140    {
11141        const FIELDS: &[&str] = &[
11142            "status",
11143            "compaction_groups",
11144            "compactionGroups",
11145        ];
11146
11147        #[allow(clippy::enum_variant_names)]
11148        enum GeneratedField {
11149            Status,
11150            CompactionGroups,
11151        }
11152        impl<'de> serde::Deserialize<'de> for GeneratedField {
11153            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11154            where
11155                D: serde::Deserializer<'de>,
11156            {
11157                struct GeneratedVisitor;
11158
11159                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11160                    type Value = GeneratedField;
11161
11162                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11163                        write!(formatter, "expected one of: {:?}", &FIELDS)
11164                    }
11165
11166                    #[allow(unused_variables)]
11167                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11168                    where
11169                        E: serde::de::Error,
11170                    {
11171                        match value {
11172                            "status" => Ok(GeneratedField::Status),
11173                            "compactionGroups" | "compaction_groups" => Ok(GeneratedField::CompactionGroups),
11174                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11175                        }
11176                    }
11177                }
11178                deserializer.deserialize_identifier(GeneratedVisitor)
11179            }
11180        }
11181        struct GeneratedVisitor;
11182        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11183            type Value = RiseCtlListCompactionGroupResponse;
11184
11185            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11186                formatter.write_str("struct hummock.RiseCtlListCompactionGroupResponse")
11187            }
11188
11189            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionGroupResponse, V::Error>
11190                where
11191                    V: serde::de::MapAccess<'de>,
11192            {
11193                let mut status__ = None;
11194                let mut compaction_groups__ = None;
11195                while let Some(k) = map_.next_key()? {
11196                    match k {
11197                        GeneratedField::Status => {
11198                            if status__.is_some() {
11199                                return Err(serde::de::Error::duplicate_field("status"));
11200                            }
11201                            status__ = map_.next_value()?;
11202                        }
11203                        GeneratedField::CompactionGroups => {
11204                            if compaction_groups__.is_some() {
11205                                return Err(serde::de::Error::duplicate_field("compactionGroups"));
11206                            }
11207                            compaction_groups__ = Some(map_.next_value()?);
11208                        }
11209                    }
11210                }
11211                Ok(RiseCtlListCompactionGroupResponse {
11212                    status: status__,
11213                    compaction_groups: compaction_groups__.unwrap_or_default(),
11214                })
11215            }
11216        }
11217        deserializer.deserialize_struct("hummock.RiseCtlListCompactionGroupResponse", FIELDS, GeneratedVisitor)
11218    }
11219}
11220impl serde::Serialize for RiseCtlListCompactionStatusRequest {
11221    #[allow(deprecated)]
11222    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11223    where
11224        S: serde::Serializer,
11225    {
11226        use serde::ser::SerializeStruct;
11227        let len = 0;
11228        let struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionStatusRequest", len)?;
11229        struct_ser.end()
11230    }
11231}
11232impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionStatusRequest {
11233    #[allow(deprecated)]
11234    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11235    where
11236        D: serde::Deserializer<'de>,
11237    {
11238        const FIELDS: &[&str] = &[
11239        ];
11240
11241        #[allow(clippy::enum_variant_names)]
11242        enum GeneratedField {
11243        }
11244        impl<'de> serde::Deserialize<'de> for GeneratedField {
11245            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11246            where
11247                D: serde::Deserializer<'de>,
11248            {
11249                struct GeneratedVisitor;
11250
11251                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11252                    type Value = GeneratedField;
11253
11254                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11255                        write!(formatter, "expected one of: {:?}", &FIELDS)
11256                    }
11257
11258                    #[allow(unused_variables)]
11259                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11260                    where
11261                        E: serde::de::Error,
11262                    {
11263                            Err(serde::de::Error::unknown_field(value, FIELDS))
11264                    }
11265                }
11266                deserializer.deserialize_identifier(GeneratedVisitor)
11267            }
11268        }
11269        struct GeneratedVisitor;
11270        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11271            type Value = RiseCtlListCompactionStatusRequest;
11272
11273            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11274                formatter.write_str("struct hummock.RiseCtlListCompactionStatusRequest")
11275            }
11276
11277            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionStatusRequest, V::Error>
11278                where
11279                    V: serde::de::MapAccess<'de>,
11280            {
11281                while map_.next_key::<GeneratedField>()?.is_some() {
11282                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11283                }
11284                Ok(RiseCtlListCompactionStatusRequest {
11285                })
11286            }
11287        }
11288        deserializer.deserialize_struct("hummock.RiseCtlListCompactionStatusRequest", FIELDS, GeneratedVisitor)
11289    }
11290}
11291impl serde::Serialize for RiseCtlListCompactionStatusResponse {
11292    #[allow(deprecated)]
11293    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11294    where
11295        S: serde::Serializer,
11296    {
11297        use serde::ser::SerializeStruct;
11298        let mut len = 0;
11299        if !self.compaction_statuses.is_empty() {
11300            len += 1;
11301        }
11302        if !self.task_assignment.is_empty() {
11303            len += 1;
11304        }
11305        if !self.task_progress.is_empty() {
11306            len += 1;
11307        }
11308        let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlListCompactionStatusResponse", len)?;
11309        if !self.compaction_statuses.is_empty() {
11310            struct_ser.serialize_field("compactionStatuses", &self.compaction_statuses)?;
11311        }
11312        if !self.task_assignment.is_empty() {
11313            struct_ser.serialize_field("taskAssignment", &self.task_assignment)?;
11314        }
11315        if !self.task_progress.is_empty() {
11316            struct_ser.serialize_field("taskProgress", &self.task_progress)?;
11317        }
11318        struct_ser.end()
11319    }
11320}
11321impl<'de> serde::Deserialize<'de> for RiseCtlListCompactionStatusResponse {
11322    #[allow(deprecated)]
11323    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11324    where
11325        D: serde::Deserializer<'de>,
11326    {
11327        const FIELDS: &[&str] = &[
11328            "compaction_statuses",
11329            "compactionStatuses",
11330            "task_assignment",
11331            "taskAssignment",
11332            "task_progress",
11333            "taskProgress",
11334        ];
11335
11336        #[allow(clippy::enum_variant_names)]
11337        enum GeneratedField {
11338            CompactionStatuses,
11339            TaskAssignment,
11340            TaskProgress,
11341        }
11342        impl<'de> serde::Deserialize<'de> for GeneratedField {
11343            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11344            where
11345                D: serde::Deserializer<'de>,
11346            {
11347                struct GeneratedVisitor;
11348
11349                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11350                    type Value = GeneratedField;
11351
11352                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11353                        write!(formatter, "expected one of: {:?}", &FIELDS)
11354                    }
11355
11356                    #[allow(unused_variables)]
11357                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11358                    where
11359                        E: serde::de::Error,
11360                    {
11361                        match value {
11362                            "compactionStatuses" | "compaction_statuses" => Ok(GeneratedField::CompactionStatuses),
11363                            "taskAssignment" | "task_assignment" => Ok(GeneratedField::TaskAssignment),
11364                            "taskProgress" | "task_progress" => Ok(GeneratedField::TaskProgress),
11365                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11366                        }
11367                    }
11368                }
11369                deserializer.deserialize_identifier(GeneratedVisitor)
11370            }
11371        }
11372        struct GeneratedVisitor;
11373        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11374            type Value = RiseCtlListCompactionStatusResponse;
11375
11376            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11377                formatter.write_str("struct hummock.RiseCtlListCompactionStatusResponse")
11378            }
11379
11380            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlListCompactionStatusResponse, V::Error>
11381                where
11382                    V: serde::de::MapAccess<'de>,
11383            {
11384                let mut compaction_statuses__ = None;
11385                let mut task_assignment__ = None;
11386                let mut task_progress__ = None;
11387                while let Some(k) = map_.next_key()? {
11388                    match k {
11389                        GeneratedField::CompactionStatuses => {
11390                            if compaction_statuses__.is_some() {
11391                                return Err(serde::de::Error::duplicate_field("compactionStatuses"));
11392                            }
11393                            compaction_statuses__ = Some(map_.next_value()?);
11394                        }
11395                        GeneratedField::TaskAssignment => {
11396                            if task_assignment__.is_some() {
11397                                return Err(serde::de::Error::duplicate_field("taskAssignment"));
11398                            }
11399                            task_assignment__ = Some(map_.next_value()?);
11400                        }
11401                        GeneratedField::TaskProgress => {
11402                            if task_progress__.is_some() {
11403                                return Err(serde::de::Error::duplicate_field("taskProgress"));
11404                            }
11405                            task_progress__ = Some(map_.next_value()?);
11406                        }
11407                    }
11408                }
11409                Ok(RiseCtlListCompactionStatusResponse {
11410                    compaction_statuses: compaction_statuses__.unwrap_or_default(),
11411                    task_assignment: task_assignment__.unwrap_or_default(),
11412                    task_progress: task_progress__.unwrap_or_default(),
11413                })
11414            }
11415        }
11416        deserializer.deserialize_struct("hummock.RiseCtlListCompactionStatusResponse", FIELDS, GeneratedVisitor)
11417    }
11418}
11419impl serde::Serialize for RiseCtlPauseVersionCheckpointRequest {
11420    #[allow(deprecated)]
11421    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11422    where
11423        S: serde::Serializer,
11424    {
11425        use serde::ser::SerializeStruct;
11426        let len = 0;
11427        let struct_ser = serializer.serialize_struct("hummock.RiseCtlPauseVersionCheckpointRequest", len)?;
11428        struct_ser.end()
11429    }
11430}
11431impl<'de> serde::Deserialize<'de> for RiseCtlPauseVersionCheckpointRequest {
11432    #[allow(deprecated)]
11433    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11434    where
11435        D: serde::Deserializer<'de>,
11436    {
11437        const FIELDS: &[&str] = &[
11438        ];
11439
11440        #[allow(clippy::enum_variant_names)]
11441        enum GeneratedField {
11442        }
11443        impl<'de> serde::Deserialize<'de> for GeneratedField {
11444            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11445            where
11446                D: serde::Deserializer<'de>,
11447            {
11448                struct GeneratedVisitor;
11449
11450                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11451                    type Value = GeneratedField;
11452
11453                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11454                        write!(formatter, "expected one of: {:?}", &FIELDS)
11455                    }
11456
11457                    #[allow(unused_variables)]
11458                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11459                    where
11460                        E: serde::de::Error,
11461                    {
11462                            Err(serde::de::Error::unknown_field(value, FIELDS))
11463                    }
11464                }
11465                deserializer.deserialize_identifier(GeneratedVisitor)
11466            }
11467        }
11468        struct GeneratedVisitor;
11469        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11470            type Value = RiseCtlPauseVersionCheckpointRequest;
11471
11472            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11473                formatter.write_str("struct hummock.RiseCtlPauseVersionCheckpointRequest")
11474            }
11475
11476            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlPauseVersionCheckpointRequest, V::Error>
11477                where
11478                    V: serde::de::MapAccess<'de>,
11479            {
11480                while map_.next_key::<GeneratedField>()?.is_some() {
11481                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11482                }
11483                Ok(RiseCtlPauseVersionCheckpointRequest {
11484                })
11485            }
11486        }
11487        deserializer.deserialize_struct("hummock.RiseCtlPauseVersionCheckpointRequest", FIELDS, GeneratedVisitor)
11488    }
11489}
11490impl serde::Serialize for RiseCtlPauseVersionCheckpointResponse {
11491    #[allow(deprecated)]
11492    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11493    where
11494        S: serde::Serializer,
11495    {
11496        use serde::ser::SerializeStruct;
11497        let len = 0;
11498        let struct_ser = serializer.serialize_struct("hummock.RiseCtlPauseVersionCheckpointResponse", len)?;
11499        struct_ser.end()
11500    }
11501}
11502impl<'de> serde::Deserialize<'de> for RiseCtlPauseVersionCheckpointResponse {
11503    #[allow(deprecated)]
11504    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11505    where
11506        D: serde::Deserializer<'de>,
11507    {
11508        const FIELDS: &[&str] = &[
11509        ];
11510
11511        #[allow(clippy::enum_variant_names)]
11512        enum GeneratedField {
11513        }
11514        impl<'de> serde::Deserialize<'de> for GeneratedField {
11515            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11516            where
11517                D: serde::Deserializer<'de>,
11518            {
11519                struct GeneratedVisitor;
11520
11521                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11522                    type Value = GeneratedField;
11523
11524                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11525                        write!(formatter, "expected one of: {:?}", &FIELDS)
11526                    }
11527
11528                    #[allow(unused_variables)]
11529                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11530                    where
11531                        E: serde::de::Error,
11532                    {
11533                            Err(serde::de::Error::unknown_field(value, FIELDS))
11534                    }
11535                }
11536                deserializer.deserialize_identifier(GeneratedVisitor)
11537            }
11538        }
11539        struct GeneratedVisitor;
11540        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11541            type Value = RiseCtlPauseVersionCheckpointResponse;
11542
11543            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11544                formatter.write_str("struct hummock.RiseCtlPauseVersionCheckpointResponse")
11545            }
11546
11547            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlPauseVersionCheckpointResponse, V::Error>
11548                where
11549                    V: serde::de::MapAccess<'de>,
11550            {
11551                while map_.next_key::<GeneratedField>()?.is_some() {
11552                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11553                }
11554                Ok(RiseCtlPauseVersionCheckpointResponse {
11555                })
11556            }
11557        }
11558        deserializer.deserialize_struct("hummock.RiseCtlPauseVersionCheckpointResponse", FIELDS, GeneratedVisitor)
11559    }
11560}
11561impl serde::Serialize for RiseCtlRebuildTableStatsRequest {
11562    #[allow(deprecated)]
11563    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11564    where
11565        S: serde::Serializer,
11566    {
11567        use serde::ser::SerializeStruct;
11568        let len = 0;
11569        let struct_ser = serializer.serialize_struct("hummock.RiseCtlRebuildTableStatsRequest", len)?;
11570        struct_ser.end()
11571    }
11572}
11573impl<'de> serde::Deserialize<'de> for RiseCtlRebuildTableStatsRequest {
11574    #[allow(deprecated)]
11575    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11576    where
11577        D: serde::Deserializer<'de>,
11578    {
11579        const FIELDS: &[&str] = &[
11580        ];
11581
11582        #[allow(clippy::enum_variant_names)]
11583        enum GeneratedField {
11584        }
11585        impl<'de> serde::Deserialize<'de> for GeneratedField {
11586            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11587            where
11588                D: serde::Deserializer<'de>,
11589            {
11590                struct GeneratedVisitor;
11591
11592                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11593                    type Value = GeneratedField;
11594
11595                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11596                        write!(formatter, "expected one of: {:?}", &FIELDS)
11597                    }
11598
11599                    #[allow(unused_variables)]
11600                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11601                    where
11602                        E: serde::de::Error,
11603                    {
11604                            Err(serde::de::Error::unknown_field(value, FIELDS))
11605                    }
11606                }
11607                deserializer.deserialize_identifier(GeneratedVisitor)
11608            }
11609        }
11610        struct GeneratedVisitor;
11611        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11612            type Value = RiseCtlRebuildTableStatsRequest;
11613
11614            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11615                formatter.write_str("struct hummock.RiseCtlRebuildTableStatsRequest")
11616            }
11617
11618            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlRebuildTableStatsRequest, V::Error>
11619                where
11620                    V: serde::de::MapAccess<'de>,
11621            {
11622                while map_.next_key::<GeneratedField>()?.is_some() {
11623                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11624                }
11625                Ok(RiseCtlRebuildTableStatsRequest {
11626                })
11627            }
11628        }
11629        deserializer.deserialize_struct("hummock.RiseCtlRebuildTableStatsRequest", FIELDS, GeneratedVisitor)
11630    }
11631}
11632impl serde::Serialize for RiseCtlRebuildTableStatsResponse {
11633    #[allow(deprecated)]
11634    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11635    where
11636        S: serde::Serializer,
11637    {
11638        use serde::ser::SerializeStruct;
11639        let len = 0;
11640        let struct_ser = serializer.serialize_struct("hummock.RiseCtlRebuildTableStatsResponse", len)?;
11641        struct_ser.end()
11642    }
11643}
11644impl<'de> serde::Deserialize<'de> for RiseCtlRebuildTableStatsResponse {
11645    #[allow(deprecated)]
11646    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11647    where
11648        D: serde::Deserializer<'de>,
11649    {
11650        const FIELDS: &[&str] = &[
11651        ];
11652
11653        #[allow(clippy::enum_variant_names)]
11654        enum GeneratedField {
11655        }
11656        impl<'de> serde::Deserialize<'de> for GeneratedField {
11657            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11658            where
11659                D: serde::Deserializer<'de>,
11660            {
11661                struct GeneratedVisitor;
11662
11663                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11664                    type Value = GeneratedField;
11665
11666                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11667                        write!(formatter, "expected one of: {:?}", &FIELDS)
11668                    }
11669
11670                    #[allow(unused_variables)]
11671                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11672                    where
11673                        E: serde::de::Error,
11674                    {
11675                            Err(serde::de::Error::unknown_field(value, FIELDS))
11676                    }
11677                }
11678                deserializer.deserialize_identifier(GeneratedVisitor)
11679            }
11680        }
11681        struct GeneratedVisitor;
11682        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11683            type Value = RiseCtlRebuildTableStatsResponse;
11684
11685            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11686                formatter.write_str("struct hummock.RiseCtlRebuildTableStatsResponse")
11687            }
11688
11689            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlRebuildTableStatsResponse, V::Error>
11690                where
11691                    V: serde::de::MapAccess<'de>,
11692            {
11693                while map_.next_key::<GeneratedField>()?.is_some() {
11694                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11695                }
11696                Ok(RiseCtlRebuildTableStatsResponse {
11697                })
11698            }
11699        }
11700        deserializer.deserialize_struct("hummock.RiseCtlRebuildTableStatsResponse", FIELDS, GeneratedVisitor)
11701    }
11702}
11703impl serde::Serialize for RiseCtlResumeVersionCheckpointRequest {
11704    #[allow(deprecated)]
11705    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11706    where
11707        S: serde::Serializer,
11708    {
11709        use serde::ser::SerializeStruct;
11710        let len = 0;
11711        let struct_ser = serializer.serialize_struct("hummock.RiseCtlResumeVersionCheckpointRequest", len)?;
11712        struct_ser.end()
11713    }
11714}
11715impl<'de> serde::Deserialize<'de> for RiseCtlResumeVersionCheckpointRequest {
11716    #[allow(deprecated)]
11717    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11718    where
11719        D: serde::Deserializer<'de>,
11720    {
11721        const FIELDS: &[&str] = &[
11722        ];
11723
11724        #[allow(clippy::enum_variant_names)]
11725        enum GeneratedField {
11726        }
11727        impl<'de> serde::Deserialize<'de> for GeneratedField {
11728            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11729            where
11730                D: serde::Deserializer<'de>,
11731            {
11732                struct GeneratedVisitor;
11733
11734                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11735                    type Value = GeneratedField;
11736
11737                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11738                        write!(formatter, "expected one of: {:?}", &FIELDS)
11739                    }
11740
11741                    #[allow(unused_variables)]
11742                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11743                    where
11744                        E: serde::de::Error,
11745                    {
11746                            Err(serde::de::Error::unknown_field(value, FIELDS))
11747                    }
11748                }
11749                deserializer.deserialize_identifier(GeneratedVisitor)
11750            }
11751        }
11752        struct GeneratedVisitor;
11753        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11754            type Value = RiseCtlResumeVersionCheckpointRequest;
11755
11756            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11757                formatter.write_str("struct hummock.RiseCtlResumeVersionCheckpointRequest")
11758            }
11759
11760            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlResumeVersionCheckpointRequest, V::Error>
11761                where
11762                    V: serde::de::MapAccess<'de>,
11763            {
11764                while map_.next_key::<GeneratedField>()?.is_some() {
11765                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11766                }
11767                Ok(RiseCtlResumeVersionCheckpointRequest {
11768                })
11769            }
11770        }
11771        deserializer.deserialize_struct("hummock.RiseCtlResumeVersionCheckpointRequest", FIELDS, GeneratedVisitor)
11772    }
11773}
11774impl serde::Serialize for RiseCtlResumeVersionCheckpointResponse {
11775    #[allow(deprecated)]
11776    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11777    where
11778        S: serde::Serializer,
11779    {
11780        use serde::ser::SerializeStruct;
11781        let len = 0;
11782        let struct_ser = serializer.serialize_struct("hummock.RiseCtlResumeVersionCheckpointResponse", len)?;
11783        struct_ser.end()
11784    }
11785}
11786impl<'de> serde::Deserialize<'de> for RiseCtlResumeVersionCheckpointResponse {
11787    #[allow(deprecated)]
11788    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11789    where
11790        D: serde::Deserializer<'de>,
11791    {
11792        const FIELDS: &[&str] = &[
11793        ];
11794
11795        #[allow(clippy::enum_variant_names)]
11796        enum GeneratedField {
11797        }
11798        impl<'de> serde::Deserialize<'de> for GeneratedField {
11799            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11800            where
11801                D: serde::Deserializer<'de>,
11802            {
11803                struct GeneratedVisitor;
11804
11805                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11806                    type Value = GeneratedField;
11807
11808                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11809                        write!(formatter, "expected one of: {:?}", &FIELDS)
11810                    }
11811
11812                    #[allow(unused_variables)]
11813                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11814                    where
11815                        E: serde::de::Error,
11816                    {
11817                            Err(serde::de::Error::unknown_field(value, FIELDS))
11818                    }
11819                }
11820                deserializer.deserialize_identifier(GeneratedVisitor)
11821            }
11822        }
11823        struct GeneratedVisitor;
11824        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11825            type Value = RiseCtlResumeVersionCheckpointResponse;
11826
11827            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11828                formatter.write_str("struct hummock.RiseCtlResumeVersionCheckpointResponse")
11829            }
11830
11831            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlResumeVersionCheckpointResponse, V::Error>
11832                where
11833                    V: serde::de::MapAccess<'de>,
11834            {
11835                while map_.next_key::<GeneratedField>()?.is_some() {
11836                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11837                }
11838                Ok(RiseCtlResumeVersionCheckpointResponse {
11839                })
11840            }
11841        }
11842        deserializer.deserialize_struct("hummock.RiseCtlResumeVersionCheckpointResponse", FIELDS, GeneratedVisitor)
11843    }
11844}
11845impl serde::Serialize for RiseCtlUpdateCompactionConfigRequest {
11846    #[allow(deprecated)]
11847    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11848    where
11849        S: serde::Serializer,
11850    {
11851        use serde::ser::SerializeStruct;
11852        let mut len = 0;
11853        if !self.compaction_group_ids.is_empty() {
11854            len += 1;
11855        }
11856        if !self.configs.is_empty() {
11857            len += 1;
11858        }
11859        let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest", len)?;
11860        if !self.compaction_group_ids.is_empty() {
11861            struct_ser.serialize_field("compactionGroupIds", &self.compaction_group_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
11862        }
11863        if !self.configs.is_empty() {
11864            struct_ser.serialize_field("configs", &self.configs)?;
11865        }
11866        struct_ser.end()
11867    }
11868}
11869impl<'de> serde::Deserialize<'de> for RiseCtlUpdateCompactionConfigRequest {
11870    #[allow(deprecated)]
11871    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11872    where
11873        D: serde::Deserializer<'de>,
11874    {
11875        const FIELDS: &[&str] = &[
11876            "compaction_group_ids",
11877            "compactionGroupIds",
11878            "configs",
11879        ];
11880
11881        #[allow(clippy::enum_variant_names)]
11882        enum GeneratedField {
11883            CompactionGroupIds,
11884            Configs,
11885        }
11886        impl<'de> serde::Deserialize<'de> for GeneratedField {
11887            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11888            where
11889                D: serde::Deserializer<'de>,
11890            {
11891                struct GeneratedVisitor;
11892
11893                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11894                    type Value = GeneratedField;
11895
11896                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11897                        write!(formatter, "expected one of: {:?}", &FIELDS)
11898                    }
11899
11900                    #[allow(unused_variables)]
11901                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11902                    where
11903                        E: serde::de::Error,
11904                    {
11905                        match value {
11906                            "compactionGroupIds" | "compaction_group_ids" => Ok(GeneratedField::CompactionGroupIds),
11907                            "configs" => Ok(GeneratedField::Configs),
11908                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11909                        }
11910                    }
11911                }
11912                deserializer.deserialize_identifier(GeneratedVisitor)
11913            }
11914        }
11915        struct GeneratedVisitor;
11916        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11917            type Value = RiseCtlUpdateCompactionConfigRequest;
11918
11919            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11920                formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigRequest")
11921            }
11922
11923            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlUpdateCompactionConfigRequest, V::Error>
11924                where
11925                    V: serde::de::MapAccess<'de>,
11926            {
11927                let mut compaction_group_ids__ = None;
11928                let mut configs__ = None;
11929                while let Some(k) = map_.next_key()? {
11930                    match k {
11931                        GeneratedField::CompactionGroupIds => {
11932                            if compaction_group_ids__.is_some() {
11933                                return Err(serde::de::Error::duplicate_field("compactionGroupIds"));
11934                            }
11935                            compaction_group_ids__ = 
11936                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11937                                    .into_iter().map(|x| x.0).collect())
11938                            ;
11939                        }
11940                        GeneratedField::Configs => {
11941                            if configs__.is_some() {
11942                                return Err(serde::de::Error::duplicate_field("configs"));
11943                            }
11944                            configs__ = Some(map_.next_value()?);
11945                        }
11946                    }
11947                }
11948                Ok(RiseCtlUpdateCompactionConfigRequest {
11949                    compaction_group_ids: compaction_group_ids__.unwrap_or_default(),
11950                    configs: configs__.unwrap_or_default(),
11951                })
11952            }
11953        }
11954        deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest", FIELDS, GeneratedVisitor)
11955    }
11956}
11957impl serde::Serialize for rise_ctl_update_compaction_config_request::CompressionAlgorithm {
11958    #[allow(deprecated)]
11959    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11960    where
11961        S: serde::Serializer,
11962    {
11963        use serde::ser::SerializeStruct;
11964        let mut len = 0;
11965        if self.level != 0 {
11966            len += 1;
11967        }
11968        if !self.compression_algorithm.is_empty() {
11969            len += 1;
11970        }
11971        let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.CompressionAlgorithm", len)?;
11972        if self.level != 0 {
11973            struct_ser.serialize_field("level", &self.level)?;
11974        }
11975        if !self.compression_algorithm.is_empty() {
11976            struct_ser.serialize_field("compressionAlgorithm", &self.compression_algorithm)?;
11977        }
11978        struct_ser.end()
11979    }
11980}
11981impl<'de> serde::Deserialize<'de> for rise_ctl_update_compaction_config_request::CompressionAlgorithm {
11982    #[allow(deprecated)]
11983    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11984    where
11985        D: serde::Deserializer<'de>,
11986    {
11987        const FIELDS: &[&str] = &[
11988            "level",
11989            "compression_algorithm",
11990            "compressionAlgorithm",
11991        ];
11992
11993        #[allow(clippy::enum_variant_names)]
11994        enum GeneratedField {
11995            Level,
11996            CompressionAlgorithm,
11997        }
11998        impl<'de> serde::Deserialize<'de> for GeneratedField {
11999            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12000            where
12001                D: serde::Deserializer<'de>,
12002            {
12003                struct GeneratedVisitor;
12004
12005                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12006                    type Value = GeneratedField;
12007
12008                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12009                        write!(formatter, "expected one of: {:?}", &FIELDS)
12010                    }
12011
12012                    #[allow(unused_variables)]
12013                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12014                    where
12015                        E: serde::de::Error,
12016                    {
12017                        match value {
12018                            "level" => Ok(GeneratedField::Level),
12019                            "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
12020                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12021                        }
12022                    }
12023                }
12024                deserializer.deserialize_identifier(GeneratedVisitor)
12025            }
12026        }
12027        struct GeneratedVisitor;
12028        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12029            type Value = rise_ctl_update_compaction_config_request::CompressionAlgorithm;
12030
12031            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12032                formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigRequest.CompressionAlgorithm")
12033            }
12034
12035            fn visit_map<V>(self, mut map_: V) -> std::result::Result<rise_ctl_update_compaction_config_request::CompressionAlgorithm, V::Error>
12036                where
12037                    V: serde::de::MapAccess<'de>,
12038            {
12039                let mut level__ = None;
12040                let mut compression_algorithm__ = None;
12041                while let Some(k) = map_.next_key()? {
12042                    match k {
12043                        GeneratedField::Level => {
12044                            if level__.is_some() {
12045                                return Err(serde::de::Error::duplicate_field("level"));
12046                            }
12047                            level__ = 
12048                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12049                            ;
12050                        }
12051                        GeneratedField::CompressionAlgorithm => {
12052                            if compression_algorithm__.is_some() {
12053                                return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
12054                            }
12055                            compression_algorithm__ = Some(map_.next_value()?);
12056                        }
12057                    }
12058                }
12059                Ok(rise_ctl_update_compaction_config_request::CompressionAlgorithm {
12060                    level: level__.unwrap_or_default(),
12061                    compression_algorithm: compression_algorithm__.unwrap_or_default(),
12062                })
12063            }
12064        }
12065        deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.CompressionAlgorithm", FIELDS, GeneratedVisitor)
12066    }
12067}
12068impl serde::Serialize for rise_ctl_update_compaction_config_request::MutableConfig {
12069    #[allow(deprecated)]
12070    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12071    where
12072        S: serde::Serializer,
12073    {
12074        use serde::ser::SerializeStruct;
12075        let mut len = 0;
12076        if self.mutable_config.is_some() {
12077            len += 1;
12078        }
12079        let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.MutableConfig", len)?;
12080        if let Some(v) = self.mutable_config.as_ref() {
12081            match v {
12082                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxBytesForLevelBase(v) => {
12083                    #[allow(clippy::needless_borrow)]
12084                    #[allow(clippy::needless_borrows_for_generic_args)]
12085                    struct_ser.serialize_field("maxBytesForLevelBase", ToString::to_string(&v).as_str())?;
12086                }
12087                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxBytesForLevelMultiplier(v) => {
12088                    #[allow(clippy::needless_borrow)]
12089                    #[allow(clippy::needless_borrows_for_generic_args)]
12090                    struct_ser.serialize_field("maxBytesForLevelMultiplier", ToString::to_string(&v).as_str())?;
12091                }
12092                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxCompactionBytes(v) => {
12093                    #[allow(clippy::needless_borrow)]
12094                    #[allow(clippy::needless_borrows_for_generic_args)]
12095                    struct_ser.serialize_field("maxCompactionBytes", ToString::to_string(&v).as_str())?;
12096                }
12097                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SubLevelMaxCompactionBytes(v) => {
12098                    #[allow(clippy::needless_borrow)]
12099                    #[allow(clippy::needless_borrows_for_generic_args)]
12100                    struct_ser.serialize_field("subLevelMaxCompactionBytes", ToString::to_string(&v).as_str())?;
12101                }
12102                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0TierCompactFileNumber(v) => {
12103                    #[allow(clippy::needless_borrow)]
12104                    #[allow(clippy::needless_borrows_for_generic_args)]
12105                    struct_ser.serialize_field("level0TierCompactFileNumber", ToString::to_string(&v).as_str())?;
12106                }
12107                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::TargetFileSizeBase(v) => {
12108                    #[allow(clippy::needless_borrow)]
12109                    #[allow(clippy::needless_borrows_for_generic_args)]
12110                    struct_ser.serialize_field("targetFileSizeBase", ToString::to_string(&v).as_str())?;
12111                }
12112                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::CompactionFilterMask(v) => {
12113                    struct_ser.serialize_field("compactionFilterMask", v)?;
12114                }
12115                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxSubCompaction(v) => {
12116                    struct_ser.serialize_field("maxSubCompaction", v)?;
12117                }
12118                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdSubLevelNumber(v) => {
12119                    #[allow(clippy::needless_borrow)]
12120                    #[allow(clippy::needless_borrows_for_generic_args)]
12121                    struct_ser.serialize_field("level0StopWriteThresholdSubLevelNumber", ToString::to_string(&v).as_str())?;
12122                }
12123                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0SubLevelCompactLevelCount(v) => {
12124                    struct_ser.serialize_field("level0SubLevelCompactLevelCount", v)?;
12125                }
12126                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0OverlappingSubLevelCompactLevelCount(v) => {
12127                    struct_ser.serialize_field("level0OverlappingSubLevelCompactLevelCount", v)?;
12128                }
12129                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxSpaceReclaimBytes(v) => {
12130                    #[allow(clippy::needless_borrow)]
12131                    #[allow(clippy::needless_borrows_for_generic_args)]
12132                    struct_ser.serialize_field("maxSpaceReclaimBytes", ToString::to_string(&v).as_str())?;
12133                }
12134                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0MaxCompactFileNumber(v) => {
12135                    #[allow(clippy::needless_borrow)]
12136                    #[allow(clippy::needless_borrows_for_generic_args)]
12137                    struct_ser.serialize_field("level0MaxCompactFileNumber", ToString::to_string(&v).as_str())?;
12138                }
12139                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableEmergencyPicker(v) => {
12140                    struct_ser.serialize_field("enableEmergencyPicker", v)?;
12141                }
12142                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::TombstoneReclaimRatio(v) => {
12143                    struct_ser.serialize_field("tombstoneReclaimRatio", v)?;
12144                }
12145                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::CompressionAlgorithm(v) => {
12146                    struct_ser.serialize_field("compressionAlgorithm", v)?;
12147                }
12148                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxL0CompactLevelCount(v) => {
12149                    struct_ser.serialize_field("maxL0CompactLevelCount", v)?;
12150                }
12151                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SstAllowedTrivialMoveMinSize(v) => {
12152                    #[allow(clippy::needless_borrow)]
12153                    #[allow(clippy::needless_borrows_for_generic_args)]
12154                    struct_ser.serialize_field("sstAllowedTrivialMoveMinSize", ToString::to_string(&v).as_str())?;
12155                }
12156                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SplitWeightByVnode(v) => {
12157                    struct_ser.serialize_field("splitWeightByVnode", v)?;
12158                }
12159                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::DisableAutoGroupScheduling(v) => {
12160                    struct_ser.serialize_field("disableAutoGroupScheduling", v)?;
12161                }
12162                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::MaxOverlappingLevelSize(v) => {
12163                    #[allow(clippy::needless_borrow)]
12164                    #[allow(clippy::needless_borrows_for_generic_args)]
12165                    struct_ser.serialize_field("maxOverlappingLevelSize", ToString::to_string(&v).as_str())?;
12166                }
12167                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EmergencyLevel0SstFileCount(v) => {
12168                    struct_ser.serialize_field("emergencyLevel0SstFileCount", v)?;
12169                }
12170                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EmergencyLevel0SubLevelPartition(v) => {
12171                    struct_ser.serialize_field("emergencyLevel0SubLevelPartition", v)?;
12172                }
12173                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdMaxSstCount(v) => {
12174                    struct_ser.serialize_field("level0StopWriteThresholdMaxSstCount", v)?;
12175                }
12176                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::Level0StopWriteThresholdMaxSize(v) => {
12177                    #[allow(clippy::needless_borrow)]
12178                    #[allow(clippy::needless_borrows_for_generic_args)]
12179                    struct_ser.serialize_field("level0StopWriteThresholdMaxSize", ToString::to_string(&v).as_str())?;
12180                }
12181                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::SstAllowedTrivialMoveMaxCount(v) => {
12182                    struct_ser.serialize_field("sstAllowedTrivialMoveMaxCount", v)?;
12183                }
12184                rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableOptimizeL0IntervalSelection(v) => {
12185                    struct_ser.serialize_field("enableOptimizeL0IntervalSelection", v)?;
12186                }
12187            }
12188        }
12189        struct_ser.end()
12190    }
12191}
12192impl<'de> serde::Deserialize<'de> for rise_ctl_update_compaction_config_request::MutableConfig {
12193    #[allow(deprecated)]
12194    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12195    where
12196        D: serde::Deserializer<'de>,
12197    {
12198        const FIELDS: &[&str] = &[
12199            "max_bytes_for_level_base",
12200            "maxBytesForLevelBase",
12201            "max_bytes_for_level_multiplier",
12202            "maxBytesForLevelMultiplier",
12203            "max_compaction_bytes",
12204            "maxCompactionBytes",
12205            "sub_level_max_compaction_bytes",
12206            "subLevelMaxCompactionBytes",
12207            "level0_tier_compact_file_number",
12208            "level0TierCompactFileNumber",
12209            "target_file_size_base",
12210            "targetFileSizeBase",
12211            "compaction_filter_mask",
12212            "compactionFilterMask",
12213            "max_sub_compaction",
12214            "maxSubCompaction",
12215            "level0_stop_write_threshold_sub_level_number",
12216            "level0StopWriteThresholdSubLevelNumber",
12217            "level0_sub_level_compact_level_count",
12218            "level0SubLevelCompactLevelCount",
12219            "level0_overlapping_sub_level_compact_level_count",
12220            "level0OverlappingSubLevelCompactLevelCount",
12221            "max_space_reclaim_bytes",
12222            "maxSpaceReclaimBytes",
12223            "level0_max_compact_file_number",
12224            "level0MaxCompactFileNumber",
12225            "enable_emergency_picker",
12226            "enableEmergencyPicker",
12227            "tombstone_reclaim_ratio",
12228            "tombstoneReclaimRatio",
12229            "compression_algorithm",
12230            "compressionAlgorithm",
12231            "max_l0_compact_level_count",
12232            "maxL0CompactLevelCount",
12233            "sst_allowed_trivial_move_min_size",
12234            "sstAllowedTrivialMoveMinSize",
12235            "split_weight_by_vnode",
12236            "splitWeightByVnode",
12237            "disable_auto_group_scheduling",
12238            "disableAutoGroupScheduling",
12239            "max_overlapping_level_size",
12240            "maxOverlappingLevelSize",
12241            "emergency_level0_sst_file_count",
12242            "emergencyLevel0SstFileCount",
12243            "emergency_level0_sub_level_partition",
12244            "emergencyLevel0SubLevelPartition",
12245            "level0_stop_write_threshold_max_sst_count",
12246            "level0StopWriteThresholdMaxSstCount",
12247            "level0_stop_write_threshold_max_size",
12248            "level0StopWriteThresholdMaxSize",
12249            "sst_allowed_trivial_move_max_count",
12250            "sstAllowedTrivialMoveMaxCount",
12251            "enable_optimize_l0_interval_selection",
12252            "enableOptimizeL0IntervalSelection",
12253        ];
12254
12255        #[allow(clippy::enum_variant_names)]
12256        enum GeneratedField {
12257            MaxBytesForLevelBase,
12258            MaxBytesForLevelMultiplier,
12259            MaxCompactionBytes,
12260            SubLevelMaxCompactionBytes,
12261            Level0TierCompactFileNumber,
12262            TargetFileSizeBase,
12263            CompactionFilterMask,
12264            MaxSubCompaction,
12265            Level0StopWriteThresholdSubLevelNumber,
12266            Level0SubLevelCompactLevelCount,
12267            Level0OverlappingSubLevelCompactLevelCount,
12268            MaxSpaceReclaimBytes,
12269            Level0MaxCompactFileNumber,
12270            EnableEmergencyPicker,
12271            TombstoneReclaimRatio,
12272            CompressionAlgorithm,
12273            MaxL0CompactLevelCount,
12274            SstAllowedTrivialMoveMinSize,
12275            SplitWeightByVnode,
12276            DisableAutoGroupScheduling,
12277            MaxOverlappingLevelSize,
12278            EmergencyLevel0SstFileCount,
12279            EmergencyLevel0SubLevelPartition,
12280            Level0StopWriteThresholdMaxSstCount,
12281            Level0StopWriteThresholdMaxSize,
12282            SstAllowedTrivialMoveMaxCount,
12283            EnableOptimizeL0IntervalSelection,
12284        }
12285        impl<'de> serde::Deserialize<'de> for GeneratedField {
12286            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12287            where
12288                D: serde::Deserializer<'de>,
12289            {
12290                struct GeneratedVisitor;
12291
12292                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12293                    type Value = GeneratedField;
12294
12295                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12296                        write!(formatter, "expected one of: {:?}", &FIELDS)
12297                    }
12298
12299                    #[allow(unused_variables)]
12300                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12301                    where
12302                        E: serde::de::Error,
12303                    {
12304                        match value {
12305                            "maxBytesForLevelBase" | "max_bytes_for_level_base" => Ok(GeneratedField::MaxBytesForLevelBase),
12306                            "maxBytesForLevelMultiplier" | "max_bytes_for_level_multiplier" => Ok(GeneratedField::MaxBytesForLevelMultiplier),
12307                            "maxCompactionBytes" | "max_compaction_bytes" => Ok(GeneratedField::MaxCompactionBytes),
12308                            "subLevelMaxCompactionBytes" | "sub_level_max_compaction_bytes" => Ok(GeneratedField::SubLevelMaxCompactionBytes),
12309                            "level0TierCompactFileNumber" | "level0_tier_compact_file_number" => Ok(GeneratedField::Level0TierCompactFileNumber),
12310                            "targetFileSizeBase" | "target_file_size_base" => Ok(GeneratedField::TargetFileSizeBase),
12311                            "compactionFilterMask" | "compaction_filter_mask" => Ok(GeneratedField::CompactionFilterMask),
12312                            "maxSubCompaction" | "max_sub_compaction" => Ok(GeneratedField::MaxSubCompaction),
12313                            "level0StopWriteThresholdSubLevelNumber" | "level0_stop_write_threshold_sub_level_number" => Ok(GeneratedField::Level0StopWriteThresholdSubLevelNumber),
12314                            "level0SubLevelCompactLevelCount" | "level0_sub_level_compact_level_count" => Ok(GeneratedField::Level0SubLevelCompactLevelCount),
12315                            "level0OverlappingSubLevelCompactLevelCount" | "level0_overlapping_sub_level_compact_level_count" => Ok(GeneratedField::Level0OverlappingSubLevelCompactLevelCount),
12316                            "maxSpaceReclaimBytes" | "max_space_reclaim_bytes" => Ok(GeneratedField::MaxSpaceReclaimBytes),
12317                            "level0MaxCompactFileNumber" | "level0_max_compact_file_number" => Ok(GeneratedField::Level0MaxCompactFileNumber),
12318                            "enableEmergencyPicker" | "enable_emergency_picker" => Ok(GeneratedField::EnableEmergencyPicker),
12319                            "tombstoneReclaimRatio" | "tombstone_reclaim_ratio" => Ok(GeneratedField::TombstoneReclaimRatio),
12320                            "compressionAlgorithm" | "compression_algorithm" => Ok(GeneratedField::CompressionAlgorithm),
12321                            "maxL0CompactLevelCount" | "max_l0_compact_level_count" => Ok(GeneratedField::MaxL0CompactLevelCount),
12322                            "sstAllowedTrivialMoveMinSize" | "sst_allowed_trivial_move_min_size" => Ok(GeneratedField::SstAllowedTrivialMoveMinSize),
12323                            "splitWeightByVnode" | "split_weight_by_vnode" => Ok(GeneratedField::SplitWeightByVnode),
12324                            "disableAutoGroupScheduling" | "disable_auto_group_scheduling" => Ok(GeneratedField::DisableAutoGroupScheduling),
12325                            "maxOverlappingLevelSize" | "max_overlapping_level_size" => Ok(GeneratedField::MaxOverlappingLevelSize),
12326                            "emergencyLevel0SstFileCount" | "emergency_level0_sst_file_count" => Ok(GeneratedField::EmergencyLevel0SstFileCount),
12327                            "emergencyLevel0SubLevelPartition" | "emergency_level0_sub_level_partition" => Ok(GeneratedField::EmergencyLevel0SubLevelPartition),
12328                            "level0StopWriteThresholdMaxSstCount" | "level0_stop_write_threshold_max_sst_count" => Ok(GeneratedField::Level0StopWriteThresholdMaxSstCount),
12329                            "level0StopWriteThresholdMaxSize" | "level0_stop_write_threshold_max_size" => Ok(GeneratedField::Level0StopWriteThresholdMaxSize),
12330                            "sstAllowedTrivialMoveMaxCount" | "sst_allowed_trivial_move_max_count" => Ok(GeneratedField::SstAllowedTrivialMoveMaxCount),
12331                            "enableOptimizeL0IntervalSelection" | "enable_optimize_l0_interval_selection" => Ok(GeneratedField::EnableOptimizeL0IntervalSelection),
12332                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12333                        }
12334                    }
12335                }
12336                deserializer.deserialize_identifier(GeneratedVisitor)
12337            }
12338        }
12339        struct GeneratedVisitor;
12340        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12341            type Value = rise_ctl_update_compaction_config_request::MutableConfig;
12342
12343            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12344                formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigRequest.MutableConfig")
12345            }
12346
12347            fn visit_map<V>(self, mut map_: V) -> std::result::Result<rise_ctl_update_compaction_config_request::MutableConfig, V::Error>
12348                where
12349                    V: serde::de::MapAccess<'de>,
12350            {
12351                let mut mutable_config__ = None;
12352                while let Some(k) = map_.next_key()? {
12353                    match k {
12354                        GeneratedField::MaxBytesForLevelBase => {
12355                            if mutable_config__.is_some() {
12356                                return Err(serde::de::Error::duplicate_field("maxBytesForLevelBase"));
12357                            }
12358                            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));
12359                        }
12360                        GeneratedField::MaxBytesForLevelMultiplier => {
12361                            if mutable_config__.is_some() {
12362                                return Err(serde::de::Error::duplicate_field("maxBytesForLevelMultiplier"));
12363                            }
12364                            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));
12365                        }
12366                        GeneratedField::MaxCompactionBytes => {
12367                            if mutable_config__.is_some() {
12368                                return Err(serde::de::Error::duplicate_field("maxCompactionBytes"));
12369                            }
12370                            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));
12371                        }
12372                        GeneratedField::SubLevelMaxCompactionBytes => {
12373                            if mutable_config__.is_some() {
12374                                return Err(serde::de::Error::duplicate_field("subLevelMaxCompactionBytes"));
12375                            }
12376                            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));
12377                        }
12378                        GeneratedField::Level0TierCompactFileNumber => {
12379                            if mutable_config__.is_some() {
12380                                return Err(serde::de::Error::duplicate_field("level0TierCompactFileNumber"));
12381                            }
12382                            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));
12383                        }
12384                        GeneratedField::TargetFileSizeBase => {
12385                            if mutable_config__.is_some() {
12386                                return Err(serde::de::Error::duplicate_field("targetFileSizeBase"));
12387                            }
12388                            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));
12389                        }
12390                        GeneratedField::CompactionFilterMask => {
12391                            if mutable_config__.is_some() {
12392                                return Err(serde::de::Error::duplicate_field("compactionFilterMask"));
12393                            }
12394                            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));
12395                        }
12396                        GeneratedField::MaxSubCompaction => {
12397                            if mutable_config__.is_some() {
12398                                return Err(serde::de::Error::duplicate_field("maxSubCompaction"));
12399                            }
12400                            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));
12401                        }
12402                        GeneratedField::Level0StopWriteThresholdSubLevelNumber => {
12403                            if mutable_config__.is_some() {
12404                                return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdSubLevelNumber"));
12405                            }
12406                            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));
12407                        }
12408                        GeneratedField::Level0SubLevelCompactLevelCount => {
12409                            if mutable_config__.is_some() {
12410                                return Err(serde::de::Error::duplicate_field("level0SubLevelCompactLevelCount"));
12411                            }
12412                            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));
12413                        }
12414                        GeneratedField::Level0OverlappingSubLevelCompactLevelCount => {
12415                            if mutable_config__.is_some() {
12416                                return Err(serde::de::Error::duplicate_field("level0OverlappingSubLevelCompactLevelCount"));
12417                            }
12418                            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));
12419                        }
12420                        GeneratedField::MaxSpaceReclaimBytes => {
12421                            if mutable_config__.is_some() {
12422                                return Err(serde::de::Error::duplicate_field("maxSpaceReclaimBytes"));
12423                            }
12424                            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));
12425                        }
12426                        GeneratedField::Level0MaxCompactFileNumber => {
12427                            if mutable_config__.is_some() {
12428                                return Err(serde::de::Error::duplicate_field("level0MaxCompactFileNumber"));
12429                            }
12430                            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));
12431                        }
12432                        GeneratedField::EnableEmergencyPicker => {
12433                            if mutable_config__.is_some() {
12434                                return Err(serde::de::Error::duplicate_field("enableEmergencyPicker"));
12435                            }
12436                            mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableEmergencyPicker);
12437                        }
12438                        GeneratedField::TombstoneReclaimRatio => {
12439                            if mutable_config__.is_some() {
12440                                return Err(serde::de::Error::duplicate_field("tombstoneReclaimRatio"));
12441                            }
12442                            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));
12443                        }
12444                        GeneratedField::CompressionAlgorithm => {
12445                            if mutable_config__.is_some() {
12446                                return Err(serde::de::Error::duplicate_field("compressionAlgorithm"));
12447                            }
12448                            mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::CompressionAlgorithm)
12449;
12450                        }
12451                        GeneratedField::MaxL0CompactLevelCount => {
12452                            if mutable_config__.is_some() {
12453                                return Err(serde::de::Error::duplicate_field("maxL0CompactLevelCount"));
12454                            }
12455                            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));
12456                        }
12457                        GeneratedField::SstAllowedTrivialMoveMinSize => {
12458                            if mutable_config__.is_some() {
12459                                return Err(serde::de::Error::duplicate_field("sstAllowedTrivialMoveMinSize"));
12460                            }
12461                            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));
12462                        }
12463                        GeneratedField::SplitWeightByVnode => {
12464                            if mutable_config__.is_some() {
12465                                return Err(serde::de::Error::duplicate_field("splitWeightByVnode"));
12466                            }
12467                            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));
12468                        }
12469                        GeneratedField::DisableAutoGroupScheduling => {
12470                            if mutable_config__.is_some() {
12471                                return Err(serde::de::Error::duplicate_field("disableAutoGroupScheduling"));
12472                            }
12473                            mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::DisableAutoGroupScheduling);
12474                        }
12475                        GeneratedField::MaxOverlappingLevelSize => {
12476                            if mutable_config__.is_some() {
12477                                return Err(serde::de::Error::duplicate_field("maxOverlappingLevelSize"));
12478                            }
12479                            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));
12480                        }
12481                        GeneratedField::EmergencyLevel0SstFileCount => {
12482                            if mutable_config__.is_some() {
12483                                return Err(serde::de::Error::duplicate_field("emergencyLevel0SstFileCount"));
12484                            }
12485                            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));
12486                        }
12487                        GeneratedField::EmergencyLevel0SubLevelPartition => {
12488                            if mutable_config__.is_some() {
12489                                return Err(serde::de::Error::duplicate_field("emergencyLevel0SubLevelPartition"));
12490                            }
12491                            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));
12492                        }
12493                        GeneratedField::Level0StopWriteThresholdMaxSstCount => {
12494                            if mutable_config__.is_some() {
12495                                return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdMaxSstCount"));
12496                            }
12497                            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));
12498                        }
12499                        GeneratedField::Level0StopWriteThresholdMaxSize => {
12500                            if mutable_config__.is_some() {
12501                                return Err(serde::de::Error::duplicate_field("level0StopWriteThresholdMaxSize"));
12502                            }
12503                            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));
12504                        }
12505                        GeneratedField::SstAllowedTrivialMoveMaxCount => {
12506                            if mutable_config__.is_some() {
12507                                return Err(serde::de::Error::duplicate_field("sstAllowedTrivialMoveMaxCount"));
12508                            }
12509                            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));
12510                        }
12511                        GeneratedField::EnableOptimizeL0IntervalSelection => {
12512                            if mutable_config__.is_some() {
12513                                return Err(serde::de::Error::duplicate_field("enableOptimizeL0IntervalSelection"));
12514                            }
12515                            mutable_config__ = map_.next_value::<::std::option::Option<_>>()?.map(rise_ctl_update_compaction_config_request::mutable_config::MutableConfig::EnableOptimizeL0IntervalSelection);
12516                        }
12517                    }
12518                }
12519                Ok(rise_ctl_update_compaction_config_request::MutableConfig {
12520                    mutable_config: mutable_config__,
12521                })
12522            }
12523        }
12524        deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigRequest.MutableConfig", FIELDS, GeneratedVisitor)
12525    }
12526}
12527impl serde::Serialize for RiseCtlUpdateCompactionConfigResponse {
12528    #[allow(deprecated)]
12529    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12530    where
12531        S: serde::Serializer,
12532    {
12533        use serde::ser::SerializeStruct;
12534        let mut len = 0;
12535        if self.status.is_some() {
12536            len += 1;
12537        }
12538        let mut struct_ser = serializer.serialize_struct("hummock.RiseCtlUpdateCompactionConfigResponse", len)?;
12539        if let Some(v) = self.status.as_ref() {
12540            struct_ser.serialize_field("status", v)?;
12541        }
12542        struct_ser.end()
12543    }
12544}
12545impl<'de> serde::Deserialize<'de> for RiseCtlUpdateCompactionConfigResponse {
12546    #[allow(deprecated)]
12547    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12548    where
12549        D: serde::Deserializer<'de>,
12550    {
12551        const FIELDS: &[&str] = &[
12552            "status",
12553        ];
12554
12555        #[allow(clippy::enum_variant_names)]
12556        enum GeneratedField {
12557            Status,
12558        }
12559        impl<'de> serde::Deserialize<'de> for GeneratedField {
12560            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12561            where
12562                D: serde::Deserializer<'de>,
12563            {
12564                struct GeneratedVisitor;
12565
12566                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12567                    type Value = GeneratedField;
12568
12569                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12570                        write!(formatter, "expected one of: {:?}", &FIELDS)
12571                    }
12572
12573                    #[allow(unused_variables)]
12574                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12575                    where
12576                        E: serde::de::Error,
12577                    {
12578                        match value {
12579                            "status" => Ok(GeneratedField::Status),
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 = RiseCtlUpdateCompactionConfigResponse;
12590
12591            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12592                formatter.write_str("struct hummock.RiseCtlUpdateCompactionConfigResponse")
12593            }
12594
12595            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RiseCtlUpdateCompactionConfigResponse, V::Error>
12596                where
12597                    V: serde::de::MapAccess<'de>,
12598            {
12599                let mut status__ = None;
12600                while let Some(k) = map_.next_key()? {
12601                    match k {
12602                        GeneratedField::Status => {
12603                            if status__.is_some() {
12604                                return Err(serde::de::Error::duplicate_field("status"));
12605                            }
12606                            status__ = map_.next_value()?;
12607                        }
12608                    }
12609                }
12610                Ok(RiseCtlUpdateCompactionConfigResponse {
12611                    status: status__,
12612                })
12613            }
12614        }
12615        deserializer.deserialize_struct("hummock.RiseCtlUpdateCompactionConfigResponse", FIELDS, GeneratedVisitor)
12616    }
12617}
12618impl serde::Serialize for SplitCompactionGroupRequest {
12619    #[allow(deprecated)]
12620    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12621    where
12622        S: serde::Serializer,
12623    {
12624        use serde::ser::SerializeStruct;
12625        let mut len = 0;
12626        if self.group_id != 0 {
12627            len += 1;
12628        }
12629        if !self.table_ids.is_empty() {
12630            len += 1;
12631        }
12632        if self.partition_vnode_count != 0 {
12633            len += 1;
12634        }
12635        let mut struct_ser = serializer.serialize_struct("hummock.SplitCompactionGroupRequest", len)?;
12636        if self.group_id != 0 {
12637            #[allow(clippy::needless_borrow)]
12638            #[allow(clippy::needless_borrows_for_generic_args)]
12639            struct_ser.serialize_field("groupId", ToString::to_string(&self.group_id).as_str())?;
12640        }
12641        if !self.table_ids.is_empty() {
12642            struct_ser.serialize_field("tableIds", &self.table_ids)?;
12643        }
12644        if self.partition_vnode_count != 0 {
12645            struct_ser.serialize_field("partitionVnodeCount", &self.partition_vnode_count)?;
12646        }
12647        struct_ser.end()
12648    }
12649}
12650impl<'de> serde::Deserialize<'de> for SplitCompactionGroupRequest {
12651    #[allow(deprecated)]
12652    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12653    where
12654        D: serde::Deserializer<'de>,
12655    {
12656        const FIELDS: &[&str] = &[
12657            "group_id",
12658            "groupId",
12659            "table_ids",
12660            "tableIds",
12661            "partition_vnode_count",
12662            "partitionVnodeCount",
12663        ];
12664
12665        #[allow(clippy::enum_variant_names)]
12666        enum GeneratedField {
12667            GroupId,
12668            TableIds,
12669            PartitionVnodeCount,
12670        }
12671        impl<'de> serde::Deserialize<'de> for GeneratedField {
12672            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12673            where
12674                D: serde::Deserializer<'de>,
12675            {
12676                struct GeneratedVisitor;
12677
12678                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12679                    type Value = GeneratedField;
12680
12681                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12682                        write!(formatter, "expected one of: {:?}", &FIELDS)
12683                    }
12684
12685                    #[allow(unused_variables)]
12686                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12687                    where
12688                        E: serde::de::Error,
12689                    {
12690                        match value {
12691                            "groupId" | "group_id" => Ok(GeneratedField::GroupId),
12692                            "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
12693                            "partitionVnodeCount" | "partition_vnode_count" => Ok(GeneratedField::PartitionVnodeCount),
12694                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12695                        }
12696                    }
12697                }
12698                deserializer.deserialize_identifier(GeneratedVisitor)
12699            }
12700        }
12701        struct GeneratedVisitor;
12702        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12703            type Value = SplitCompactionGroupRequest;
12704
12705            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12706                formatter.write_str("struct hummock.SplitCompactionGroupRequest")
12707            }
12708
12709            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SplitCompactionGroupRequest, V::Error>
12710                where
12711                    V: serde::de::MapAccess<'de>,
12712            {
12713                let mut group_id__ = None;
12714                let mut table_ids__ = None;
12715                let mut partition_vnode_count__ = None;
12716                while let Some(k) = map_.next_key()? {
12717                    match k {
12718                        GeneratedField::GroupId => {
12719                            if group_id__.is_some() {
12720                                return Err(serde::de::Error::duplicate_field("groupId"));
12721                            }
12722                            group_id__ = 
12723                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12724                            ;
12725                        }
12726                        GeneratedField::TableIds => {
12727                            if table_ids__.is_some() {
12728                                return Err(serde::de::Error::duplicate_field("tableIds"));
12729                            }
12730                            table_ids__ = 
12731                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12732                                    .into_iter().map(|x| x.0).collect())
12733                            ;
12734                        }
12735                        GeneratedField::PartitionVnodeCount => {
12736                            if partition_vnode_count__.is_some() {
12737                                return Err(serde::de::Error::duplicate_field("partitionVnodeCount"));
12738                            }
12739                            partition_vnode_count__ = 
12740                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12741                            ;
12742                        }
12743                    }
12744                }
12745                Ok(SplitCompactionGroupRequest {
12746                    group_id: group_id__.unwrap_or_default(),
12747                    table_ids: table_ids__.unwrap_or_default(),
12748                    partition_vnode_count: partition_vnode_count__.unwrap_or_default(),
12749                })
12750            }
12751        }
12752        deserializer.deserialize_struct("hummock.SplitCompactionGroupRequest", FIELDS, GeneratedVisitor)
12753    }
12754}
12755impl serde::Serialize for SplitCompactionGroupResponse {
12756    #[allow(deprecated)]
12757    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12758    where
12759        S: serde::Serializer,
12760    {
12761        use serde::ser::SerializeStruct;
12762        let mut len = 0;
12763        if self.new_group_id != 0 {
12764            len += 1;
12765        }
12766        let mut struct_ser = serializer.serialize_struct("hummock.SplitCompactionGroupResponse", len)?;
12767        if self.new_group_id != 0 {
12768            #[allow(clippy::needless_borrow)]
12769            #[allow(clippy::needless_borrows_for_generic_args)]
12770            struct_ser.serialize_field("newGroupId", ToString::to_string(&self.new_group_id).as_str())?;
12771        }
12772        struct_ser.end()
12773    }
12774}
12775impl<'de> serde::Deserialize<'de> for SplitCompactionGroupResponse {
12776    #[allow(deprecated)]
12777    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12778    where
12779        D: serde::Deserializer<'de>,
12780    {
12781        const FIELDS: &[&str] = &[
12782            "new_group_id",
12783            "newGroupId",
12784        ];
12785
12786        #[allow(clippy::enum_variant_names)]
12787        enum GeneratedField {
12788            NewGroupId,
12789        }
12790        impl<'de> serde::Deserialize<'de> for GeneratedField {
12791            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12792            where
12793                D: serde::Deserializer<'de>,
12794            {
12795                struct GeneratedVisitor;
12796
12797                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12798                    type Value = GeneratedField;
12799
12800                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12801                        write!(formatter, "expected one of: {:?}", &FIELDS)
12802                    }
12803
12804                    #[allow(unused_variables)]
12805                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12806                    where
12807                        E: serde::de::Error,
12808                    {
12809                        match value {
12810                            "newGroupId" | "new_group_id" => Ok(GeneratedField::NewGroupId),
12811                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12812                        }
12813                    }
12814                }
12815                deserializer.deserialize_identifier(GeneratedVisitor)
12816            }
12817        }
12818        struct GeneratedVisitor;
12819        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12820            type Value = SplitCompactionGroupResponse;
12821
12822            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12823                formatter.write_str("struct hummock.SplitCompactionGroupResponse")
12824            }
12825
12826            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SplitCompactionGroupResponse, V::Error>
12827                where
12828                    V: serde::de::MapAccess<'de>,
12829            {
12830                let mut new_group_id__ = None;
12831                while let Some(k) = map_.next_key()? {
12832                    match k {
12833                        GeneratedField::NewGroupId => {
12834                            if new_group_id__.is_some() {
12835                                return Err(serde::de::Error::duplicate_field("newGroupId"));
12836                            }
12837                            new_group_id__ = 
12838                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12839                            ;
12840                        }
12841                    }
12842                }
12843                Ok(SplitCompactionGroupResponse {
12844                    new_group_id: new_group_id__.unwrap_or_default(),
12845                })
12846            }
12847        }
12848        deserializer.deserialize_struct("hummock.SplitCompactionGroupResponse", FIELDS, GeneratedVisitor)
12849    }
12850}
12851impl serde::Serialize for SstableInfo {
12852    #[allow(deprecated)]
12853    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12854    where
12855        S: serde::Serializer,
12856    {
12857        use serde::ser::SerializeStruct;
12858        let mut len = 0;
12859        if self.object_id != 0 {
12860            len += 1;
12861        }
12862        if self.sst_id != 0 {
12863            len += 1;
12864        }
12865        if self.key_range.is_some() {
12866            len += 1;
12867        }
12868        if self.file_size != 0 {
12869            len += 1;
12870        }
12871        if !self.table_ids.is_empty() {
12872            len += 1;
12873        }
12874        if self.meta_offset != 0 {
12875            len += 1;
12876        }
12877        if self.stale_key_count != 0 {
12878            len += 1;
12879        }
12880        if self.total_key_count != 0 {
12881            len += 1;
12882        }
12883        if self.min_epoch != 0 {
12884            len += 1;
12885        }
12886        if self.max_epoch != 0 {
12887            len += 1;
12888        }
12889        if self.uncompressed_file_size != 0 {
12890            len += 1;
12891        }
12892        if self.range_tombstone_count != 0 {
12893            len += 1;
12894        }
12895        if self.bloom_filter_kind != 0 {
12896            len += 1;
12897        }
12898        if self.sst_size != 0 {
12899            len += 1;
12900        }
12901        let mut struct_ser = serializer.serialize_struct("hummock.SstableInfo", len)?;
12902        if self.object_id != 0 {
12903            #[allow(clippy::needless_borrow)]
12904            #[allow(clippy::needless_borrows_for_generic_args)]
12905            struct_ser.serialize_field("objectId", ToString::to_string(&self.object_id).as_str())?;
12906        }
12907        if self.sst_id != 0 {
12908            #[allow(clippy::needless_borrow)]
12909            #[allow(clippy::needless_borrows_for_generic_args)]
12910            struct_ser.serialize_field("sstId", ToString::to_string(&self.sst_id).as_str())?;
12911        }
12912        if let Some(v) = self.key_range.as_ref() {
12913            struct_ser.serialize_field("keyRange", v)?;
12914        }
12915        if self.file_size != 0 {
12916            #[allow(clippy::needless_borrow)]
12917            #[allow(clippy::needless_borrows_for_generic_args)]
12918            struct_ser.serialize_field("fileSize", ToString::to_string(&self.file_size).as_str())?;
12919        }
12920        if !self.table_ids.is_empty() {
12921            struct_ser.serialize_field("tableIds", &self.table_ids)?;
12922        }
12923        if self.meta_offset != 0 {
12924            #[allow(clippy::needless_borrow)]
12925            #[allow(clippy::needless_borrows_for_generic_args)]
12926            struct_ser.serialize_field("metaOffset", ToString::to_string(&self.meta_offset).as_str())?;
12927        }
12928        if self.stale_key_count != 0 {
12929            #[allow(clippy::needless_borrow)]
12930            #[allow(clippy::needless_borrows_for_generic_args)]
12931            struct_ser.serialize_field("staleKeyCount", ToString::to_string(&self.stale_key_count).as_str())?;
12932        }
12933        if self.total_key_count != 0 {
12934            #[allow(clippy::needless_borrow)]
12935            #[allow(clippy::needless_borrows_for_generic_args)]
12936            struct_ser.serialize_field("totalKeyCount", ToString::to_string(&self.total_key_count).as_str())?;
12937        }
12938        if self.min_epoch != 0 {
12939            #[allow(clippy::needless_borrow)]
12940            #[allow(clippy::needless_borrows_for_generic_args)]
12941            struct_ser.serialize_field("minEpoch", ToString::to_string(&self.min_epoch).as_str())?;
12942        }
12943        if self.max_epoch != 0 {
12944            #[allow(clippy::needless_borrow)]
12945            #[allow(clippy::needless_borrows_for_generic_args)]
12946            struct_ser.serialize_field("maxEpoch", ToString::to_string(&self.max_epoch).as_str())?;
12947        }
12948        if self.uncompressed_file_size != 0 {
12949            #[allow(clippy::needless_borrow)]
12950            #[allow(clippy::needless_borrows_for_generic_args)]
12951            struct_ser.serialize_field("uncompressedFileSize", ToString::to_string(&self.uncompressed_file_size).as_str())?;
12952        }
12953        if self.range_tombstone_count != 0 {
12954            #[allow(clippy::needless_borrow)]
12955            #[allow(clippy::needless_borrows_for_generic_args)]
12956            struct_ser.serialize_field("rangeTombstoneCount", ToString::to_string(&self.range_tombstone_count).as_str())?;
12957        }
12958        if self.bloom_filter_kind != 0 {
12959            let v = BloomFilterType::try_from(self.bloom_filter_kind)
12960                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.bloom_filter_kind)))?;
12961            struct_ser.serialize_field("bloomFilterKind", &v)?;
12962        }
12963        if self.sst_size != 0 {
12964            #[allow(clippy::needless_borrow)]
12965            #[allow(clippy::needless_borrows_for_generic_args)]
12966            struct_ser.serialize_field("sstSize", ToString::to_string(&self.sst_size).as_str())?;
12967        }
12968        struct_ser.end()
12969    }
12970}
12971impl<'de> serde::Deserialize<'de> for SstableInfo {
12972    #[allow(deprecated)]
12973    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12974    where
12975        D: serde::Deserializer<'de>,
12976    {
12977        const FIELDS: &[&str] = &[
12978            "object_id",
12979            "objectId",
12980            "sst_id",
12981            "sstId",
12982            "key_range",
12983            "keyRange",
12984            "file_size",
12985            "fileSize",
12986            "table_ids",
12987            "tableIds",
12988            "meta_offset",
12989            "metaOffset",
12990            "stale_key_count",
12991            "staleKeyCount",
12992            "total_key_count",
12993            "totalKeyCount",
12994            "min_epoch",
12995            "minEpoch",
12996            "max_epoch",
12997            "maxEpoch",
12998            "uncompressed_file_size",
12999            "uncompressedFileSize",
13000            "range_tombstone_count",
13001            "rangeTombstoneCount",
13002            "bloom_filter_kind",
13003            "bloomFilterKind",
13004            "sst_size",
13005            "sstSize",
13006        ];
13007
13008        #[allow(clippy::enum_variant_names)]
13009        enum GeneratedField {
13010            ObjectId,
13011            SstId,
13012            KeyRange,
13013            FileSize,
13014            TableIds,
13015            MetaOffset,
13016            StaleKeyCount,
13017            TotalKeyCount,
13018            MinEpoch,
13019            MaxEpoch,
13020            UncompressedFileSize,
13021            RangeTombstoneCount,
13022            BloomFilterKind,
13023            SstSize,
13024        }
13025        impl<'de> serde::Deserialize<'de> for GeneratedField {
13026            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13027            where
13028                D: serde::Deserializer<'de>,
13029            {
13030                struct GeneratedVisitor;
13031
13032                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13033                    type Value = GeneratedField;
13034
13035                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13036                        write!(formatter, "expected one of: {:?}", &FIELDS)
13037                    }
13038
13039                    #[allow(unused_variables)]
13040                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13041                    where
13042                        E: serde::de::Error,
13043                    {
13044                        match value {
13045                            "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
13046                            "sstId" | "sst_id" => Ok(GeneratedField::SstId),
13047                            "keyRange" | "key_range" => Ok(GeneratedField::KeyRange),
13048                            "fileSize" | "file_size" => Ok(GeneratedField::FileSize),
13049                            "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
13050                            "metaOffset" | "meta_offset" => Ok(GeneratedField::MetaOffset),
13051                            "staleKeyCount" | "stale_key_count" => Ok(GeneratedField::StaleKeyCount),
13052                            "totalKeyCount" | "total_key_count" => Ok(GeneratedField::TotalKeyCount),
13053                            "minEpoch" | "min_epoch" => Ok(GeneratedField::MinEpoch),
13054                            "maxEpoch" | "max_epoch" => Ok(GeneratedField::MaxEpoch),
13055                            "uncompressedFileSize" | "uncompressed_file_size" => Ok(GeneratedField::UncompressedFileSize),
13056                            "rangeTombstoneCount" | "range_tombstone_count" => Ok(GeneratedField::RangeTombstoneCount),
13057                            "bloomFilterKind" | "bloom_filter_kind" => Ok(GeneratedField::BloomFilterKind),
13058                            "sstSize" | "sst_size" => Ok(GeneratedField::SstSize),
13059                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13060                        }
13061                    }
13062                }
13063                deserializer.deserialize_identifier(GeneratedVisitor)
13064            }
13065        }
13066        struct GeneratedVisitor;
13067        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13068            type Value = SstableInfo;
13069
13070            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13071                formatter.write_str("struct hummock.SstableInfo")
13072            }
13073
13074            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SstableInfo, V::Error>
13075                where
13076                    V: serde::de::MapAccess<'de>,
13077            {
13078                let mut object_id__ = None;
13079                let mut sst_id__ = None;
13080                let mut key_range__ = None;
13081                let mut file_size__ = None;
13082                let mut table_ids__ = None;
13083                let mut meta_offset__ = None;
13084                let mut stale_key_count__ = None;
13085                let mut total_key_count__ = None;
13086                let mut min_epoch__ = None;
13087                let mut max_epoch__ = None;
13088                let mut uncompressed_file_size__ = None;
13089                let mut range_tombstone_count__ = None;
13090                let mut bloom_filter_kind__ = None;
13091                let mut sst_size__ = None;
13092                while let Some(k) = map_.next_key()? {
13093                    match k {
13094                        GeneratedField::ObjectId => {
13095                            if object_id__.is_some() {
13096                                return Err(serde::de::Error::duplicate_field("objectId"));
13097                            }
13098                            object_id__ = 
13099                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13100                            ;
13101                        }
13102                        GeneratedField::SstId => {
13103                            if sst_id__.is_some() {
13104                                return Err(serde::de::Error::duplicate_field("sstId"));
13105                            }
13106                            sst_id__ = 
13107                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13108                            ;
13109                        }
13110                        GeneratedField::KeyRange => {
13111                            if key_range__.is_some() {
13112                                return Err(serde::de::Error::duplicate_field("keyRange"));
13113                            }
13114                            key_range__ = map_.next_value()?;
13115                        }
13116                        GeneratedField::FileSize => {
13117                            if file_size__.is_some() {
13118                                return Err(serde::de::Error::duplicate_field("fileSize"));
13119                            }
13120                            file_size__ = 
13121                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13122                            ;
13123                        }
13124                        GeneratedField::TableIds => {
13125                            if table_ids__.is_some() {
13126                                return Err(serde::de::Error::duplicate_field("tableIds"));
13127                            }
13128                            table_ids__ = 
13129                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13130                                    .into_iter().map(|x| x.0).collect())
13131                            ;
13132                        }
13133                        GeneratedField::MetaOffset => {
13134                            if meta_offset__.is_some() {
13135                                return Err(serde::de::Error::duplicate_field("metaOffset"));
13136                            }
13137                            meta_offset__ = 
13138                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13139                            ;
13140                        }
13141                        GeneratedField::StaleKeyCount => {
13142                            if stale_key_count__.is_some() {
13143                                return Err(serde::de::Error::duplicate_field("staleKeyCount"));
13144                            }
13145                            stale_key_count__ = 
13146                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13147                            ;
13148                        }
13149                        GeneratedField::TotalKeyCount => {
13150                            if total_key_count__.is_some() {
13151                                return Err(serde::de::Error::duplicate_field("totalKeyCount"));
13152                            }
13153                            total_key_count__ = 
13154                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13155                            ;
13156                        }
13157                        GeneratedField::MinEpoch => {
13158                            if min_epoch__.is_some() {
13159                                return Err(serde::de::Error::duplicate_field("minEpoch"));
13160                            }
13161                            min_epoch__ = 
13162                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13163                            ;
13164                        }
13165                        GeneratedField::MaxEpoch => {
13166                            if max_epoch__.is_some() {
13167                                return Err(serde::de::Error::duplicate_field("maxEpoch"));
13168                            }
13169                            max_epoch__ = 
13170                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13171                            ;
13172                        }
13173                        GeneratedField::UncompressedFileSize => {
13174                            if uncompressed_file_size__.is_some() {
13175                                return Err(serde::de::Error::duplicate_field("uncompressedFileSize"));
13176                            }
13177                            uncompressed_file_size__ = 
13178                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13179                            ;
13180                        }
13181                        GeneratedField::RangeTombstoneCount => {
13182                            if range_tombstone_count__.is_some() {
13183                                return Err(serde::de::Error::duplicate_field("rangeTombstoneCount"));
13184                            }
13185                            range_tombstone_count__ = 
13186                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13187                            ;
13188                        }
13189                        GeneratedField::BloomFilterKind => {
13190                            if bloom_filter_kind__.is_some() {
13191                                return Err(serde::de::Error::duplicate_field("bloomFilterKind"));
13192                            }
13193                            bloom_filter_kind__ = Some(map_.next_value::<BloomFilterType>()? as i32);
13194                        }
13195                        GeneratedField::SstSize => {
13196                            if sst_size__.is_some() {
13197                                return Err(serde::de::Error::duplicate_field("sstSize"));
13198                            }
13199                            sst_size__ = 
13200                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13201                            ;
13202                        }
13203                    }
13204                }
13205                Ok(SstableInfo {
13206                    object_id: object_id__.unwrap_or_default(),
13207                    sst_id: sst_id__.unwrap_or_default(),
13208                    key_range: key_range__,
13209                    file_size: file_size__.unwrap_or_default(),
13210                    table_ids: table_ids__.unwrap_or_default(),
13211                    meta_offset: meta_offset__.unwrap_or_default(),
13212                    stale_key_count: stale_key_count__.unwrap_or_default(),
13213                    total_key_count: total_key_count__.unwrap_or_default(),
13214                    min_epoch: min_epoch__.unwrap_or_default(),
13215                    max_epoch: max_epoch__.unwrap_or_default(),
13216                    uncompressed_file_size: uncompressed_file_size__.unwrap_or_default(),
13217                    range_tombstone_count: range_tombstone_count__.unwrap_or_default(),
13218                    bloom_filter_kind: bloom_filter_kind__.unwrap_or_default(),
13219                    sst_size: sst_size__.unwrap_or_default(),
13220                })
13221            }
13222        }
13223        deserializer.deserialize_struct("hummock.SstableInfo", FIELDS, GeneratedVisitor)
13224    }
13225}
13226impl serde::Serialize for StateTableInfo {
13227    #[allow(deprecated)]
13228    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13229    where
13230        S: serde::Serializer,
13231    {
13232        use serde::ser::SerializeStruct;
13233        let mut len = 0;
13234        if self.committed_epoch != 0 {
13235            len += 1;
13236        }
13237        if self.compaction_group_id != 0 {
13238            len += 1;
13239        }
13240        let mut struct_ser = serializer.serialize_struct("hummock.StateTableInfo", len)?;
13241        if self.committed_epoch != 0 {
13242            #[allow(clippy::needless_borrow)]
13243            #[allow(clippy::needless_borrows_for_generic_args)]
13244            struct_ser.serialize_field("committedEpoch", ToString::to_string(&self.committed_epoch).as_str())?;
13245        }
13246        if self.compaction_group_id != 0 {
13247            #[allow(clippy::needless_borrow)]
13248            #[allow(clippy::needless_borrows_for_generic_args)]
13249            struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
13250        }
13251        struct_ser.end()
13252    }
13253}
13254impl<'de> serde::Deserialize<'de> for StateTableInfo {
13255    #[allow(deprecated)]
13256    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13257    where
13258        D: serde::Deserializer<'de>,
13259    {
13260        const FIELDS: &[&str] = &[
13261            "committed_epoch",
13262            "committedEpoch",
13263            "compaction_group_id",
13264            "compactionGroupId",
13265        ];
13266
13267        #[allow(clippy::enum_variant_names)]
13268        enum GeneratedField {
13269            CommittedEpoch,
13270            CompactionGroupId,
13271        }
13272        impl<'de> serde::Deserialize<'de> for GeneratedField {
13273            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13274            where
13275                D: serde::Deserializer<'de>,
13276            {
13277                struct GeneratedVisitor;
13278
13279                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13280                    type Value = GeneratedField;
13281
13282                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13283                        write!(formatter, "expected one of: {:?}", &FIELDS)
13284                    }
13285
13286                    #[allow(unused_variables)]
13287                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13288                    where
13289                        E: serde::de::Error,
13290                    {
13291                        match value {
13292                            "committedEpoch" | "committed_epoch" => Ok(GeneratedField::CommittedEpoch),
13293                            "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
13294                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13295                        }
13296                    }
13297                }
13298                deserializer.deserialize_identifier(GeneratedVisitor)
13299            }
13300        }
13301        struct GeneratedVisitor;
13302        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13303            type Value = StateTableInfo;
13304
13305            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13306                formatter.write_str("struct hummock.StateTableInfo")
13307            }
13308
13309            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StateTableInfo, V::Error>
13310                where
13311                    V: serde::de::MapAccess<'de>,
13312            {
13313                let mut committed_epoch__ = None;
13314                let mut compaction_group_id__ = None;
13315                while let Some(k) = map_.next_key()? {
13316                    match k {
13317                        GeneratedField::CommittedEpoch => {
13318                            if committed_epoch__.is_some() {
13319                                return Err(serde::de::Error::duplicate_field("committedEpoch"));
13320                            }
13321                            committed_epoch__ = 
13322                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13323                            ;
13324                        }
13325                        GeneratedField::CompactionGroupId => {
13326                            if compaction_group_id__.is_some() {
13327                                return Err(serde::de::Error::duplicate_field("compactionGroupId"));
13328                            }
13329                            compaction_group_id__ = 
13330                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13331                            ;
13332                        }
13333                    }
13334                }
13335                Ok(StateTableInfo {
13336                    committed_epoch: committed_epoch__.unwrap_or_default(),
13337                    compaction_group_id: compaction_group_id__.unwrap_or_default(),
13338                })
13339            }
13340        }
13341        deserializer.deserialize_struct("hummock.StateTableInfo", FIELDS, GeneratedVisitor)
13342    }
13343}
13344impl serde::Serialize for StateTableInfoDelta {
13345    #[allow(deprecated)]
13346    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13347    where
13348        S: serde::Serializer,
13349    {
13350        use serde::ser::SerializeStruct;
13351        let mut len = 0;
13352        if self.committed_epoch != 0 {
13353            len += 1;
13354        }
13355        if self.compaction_group_id != 0 {
13356            len += 1;
13357        }
13358        let mut struct_ser = serializer.serialize_struct("hummock.StateTableInfoDelta", len)?;
13359        if self.committed_epoch != 0 {
13360            #[allow(clippy::needless_borrow)]
13361            #[allow(clippy::needless_borrows_for_generic_args)]
13362            struct_ser.serialize_field("committedEpoch", ToString::to_string(&self.committed_epoch).as_str())?;
13363        }
13364        if self.compaction_group_id != 0 {
13365            #[allow(clippy::needless_borrow)]
13366            #[allow(clippy::needless_borrows_for_generic_args)]
13367            struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
13368        }
13369        struct_ser.end()
13370    }
13371}
13372impl<'de> serde::Deserialize<'de> for StateTableInfoDelta {
13373    #[allow(deprecated)]
13374    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13375    where
13376        D: serde::Deserializer<'de>,
13377    {
13378        const FIELDS: &[&str] = &[
13379            "committed_epoch",
13380            "committedEpoch",
13381            "compaction_group_id",
13382            "compactionGroupId",
13383        ];
13384
13385        #[allow(clippy::enum_variant_names)]
13386        enum GeneratedField {
13387            CommittedEpoch,
13388            CompactionGroupId,
13389        }
13390        impl<'de> serde::Deserialize<'de> for GeneratedField {
13391            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13392            where
13393                D: serde::Deserializer<'de>,
13394            {
13395                struct GeneratedVisitor;
13396
13397                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13398                    type Value = GeneratedField;
13399
13400                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13401                        write!(formatter, "expected one of: {:?}", &FIELDS)
13402                    }
13403
13404                    #[allow(unused_variables)]
13405                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13406                    where
13407                        E: serde::de::Error,
13408                    {
13409                        match value {
13410                            "committedEpoch" | "committed_epoch" => Ok(GeneratedField::CommittedEpoch),
13411                            "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
13412                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13413                        }
13414                    }
13415                }
13416                deserializer.deserialize_identifier(GeneratedVisitor)
13417            }
13418        }
13419        struct GeneratedVisitor;
13420        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13421            type Value = StateTableInfoDelta;
13422
13423            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13424                formatter.write_str("struct hummock.StateTableInfoDelta")
13425            }
13426
13427            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StateTableInfoDelta, V::Error>
13428                where
13429                    V: serde::de::MapAccess<'de>,
13430            {
13431                let mut committed_epoch__ = None;
13432                let mut compaction_group_id__ = None;
13433                while let Some(k) = map_.next_key()? {
13434                    match k {
13435                        GeneratedField::CommittedEpoch => {
13436                            if committed_epoch__.is_some() {
13437                                return Err(serde::de::Error::duplicate_field("committedEpoch"));
13438                            }
13439                            committed_epoch__ = 
13440                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13441                            ;
13442                        }
13443                        GeneratedField::CompactionGroupId => {
13444                            if compaction_group_id__.is_some() {
13445                                return Err(serde::de::Error::duplicate_field("compactionGroupId"));
13446                            }
13447                            compaction_group_id__ = 
13448                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13449                            ;
13450                        }
13451                    }
13452                }
13453                Ok(StateTableInfoDelta {
13454                    committed_epoch: committed_epoch__.unwrap_or_default(),
13455                    compaction_group_id: compaction_group_id__.unwrap_or_default(),
13456                })
13457            }
13458        }
13459        deserializer.deserialize_struct("hummock.StateTableInfoDelta", FIELDS, GeneratedVisitor)
13460    }
13461}
13462impl serde::Serialize for SubscribeCompactionEventRequest {
13463    #[allow(deprecated)]
13464    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13465    where
13466        S: serde::Serializer,
13467    {
13468        use serde::ser::SerializeStruct;
13469        let mut len = 0;
13470        if self.create_at != 0 {
13471            len += 1;
13472        }
13473        if self.event.is_some() {
13474            len += 1;
13475        }
13476        let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest", len)?;
13477        if self.create_at != 0 {
13478            #[allow(clippy::needless_borrow)]
13479            #[allow(clippy::needless_borrows_for_generic_args)]
13480            struct_ser.serialize_field("createAt", ToString::to_string(&self.create_at).as_str())?;
13481        }
13482        if let Some(v) = self.event.as_ref() {
13483            match v {
13484                subscribe_compaction_event_request::Event::Register(v) => {
13485                    struct_ser.serialize_field("register", v)?;
13486                }
13487                subscribe_compaction_event_request::Event::PullTask(v) => {
13488                    struct_ser.serialize_field("pullTask", v)?;
13489                }
13490                subscribe_compaction_event_request::Event::ReportTask(v) => {
13491                    struct_ser.serialize_field("reportTask", v)?;
13492                }
13493                subscribe_compaction_event_request::Event::HeartBeat(v) => {
13494                    struct_ser.serialize_field("heartBeat", v)?;
13495                }
13496            }
13497        }
13498        struct_ser.end()
13499    }
13500}
13501impl<'de> serde::Deserialize<'de> for SubscribeCompactionEventRequest {
13502    #[allow(deprecated)]
13503    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13504    where
13505        D: serde::Deserializer<'de>,
13506    {
13507        const FIELDS: &[&str] = &[
13508            "create_at",
13509            "createAt",
13510            "register",
13511            "pull_task",
13512            "pullTask",
13513            "report_task",
13514            "reportTask",
13515            "heart_beat",
13516            "heartBeat",
13517        ];
13518
13519        #[allow(clippy::enum_variant_names)]
13520        enum GeneratedField {
13521            CreateAt,
13522            Register,
13523            PullTask,
13524            ReportTask,
13525            HeartBeat,
13526        }
13527        impl<'de> serde::Deserialize<'de> for GeneratedField {
13528            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13529            where
13530                D: serde::Deserializer<'de>,
13531            {
13532                struct GeneratedVisitor;
13533
13534                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13535                    type Value = GeneratedField;
13536
13537                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13538                        write!(formatter, "expected one of: {:?}", &FIELDS)
13539                    }
13540
13541                    #[allow(unused_variables)]
13542                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13543                    where
13544                        E: serde::de::Error,
13545                    {
13546                        match value {
13547                            "createAt" | "create_at" => Ok(GeneratedField::CreateAt),
13548                            "register" => Ok(GeneratedField::Register),
13549                            "pullTask" | "pull_task" => Ok(GeneratedField::PullTask),
13550                            "reportTask" | "report_task" => Ok(GeneratedField::ReportTask),
13551                            "heartBeat" | "heart_beat" => Ok(GeneratedField::HeartBeat),
13552                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13553                        }
13554                    }
13555                }
13556                deserializer.deserialize_identifier(GeneratedVisitor)
13557            }
13558        }
13559        struct GeneratedVisitor;
13560        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13561            type Value = SubscribeCompactionEventRequest;
13562
13563            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13564                formatter.write_str("struct hummock.SubscribeCompactionEventRequest")
13565            }
13566
13567            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeCompactionEventRequest, V::Error>
13568                where
13569                    V: serde::de::MapAccess<'de>,
13570            {
13571                let mut create_at__ = None;
13572                let mut event__ = None;
13573                while let Some(k) = map_.next_key()? {
13574                    match k {
13575                        GeneratedField::CreateAt => {
13576                            if create_at__.is_some() {
13577                                return Err(serde::de::Error::duplicate_field("createAt"));
13578                            }
13579                            create_at__ = 
13580                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13581                            ;
13582                        }
13583                        GeneratedField::Register => {
13584                            if event__.is_some() {
13585                                return Err(serde::de::Error::duplicate_field("register"));
13586                            }
13587                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::Register)
13588;
13589                        }
13590                        GeneratedField::PullTask => {
13591                            if event__.is_some() {
13592                                return Err(serde::de::Error::duplicate_field("pullTask"));
13593                            }
13594                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::PullTask)
13595;
13596                        }
13597                        GeneratedField::ReportTask => {
13598                            if event__.is_some() {
13599                                return Err(serde::de::Error::duplicate_field("reportTask"));
13600                            }
13601                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::ReportTask)
13602;
13603                        }
13604                        GeneratedField::HeartBeat => {
13605                            if event__.is_some() {
13606                                return Err(serde::de::Error::duplicate_field("heartBeat"));
13607                            }
13608                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_request::Event::HeartBeat)
13609;
13610                        }
13611                    }
13612                }
13613                Ok(SubscribeCompactionEventRequest {
13614                    create_at: create_at__.unwrap_or_default(),
13615                    event: event__,
13616                })
13617            }
13618        }
13619        deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest", FIELDS, GeneratedVisitor)
13620    }
13621}
13622impl serde::Serialize for subscribe_compaction_event_request::HeartBeat {
13623    #[allow(deprecated)]
13624    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13625    where
13626        S: serde::Serializer,
13627    {
13628        use serde::ser::SerializeStruct;
13629        let mut len = 0;
13630        if !self.progress.is_empty() {
13631            len += 1;
13632        }
13633        let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.HeartBeat", len)?;
13634        if !self.progress.is_empty() {
13635            struct_ser.serialize_field("progress", &self.progress)?;
13636        }
13637        struct_ser.end()
13638    }
13639}
13640impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::HeartBeat {
13641    #[allow(deprecated)]
13642    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13643    where
13644        D: serde::Deserializer<'de>,
13645    {
13646        const FIELDS: &[&str] = &[
13647            "progress",
13648        ];
13649
13650        #[allow(clippy::enum_variant_names)]
13651        enum GeneratedField {
13652            Progress,
13653        }
13654        impl<'de> serde::Deserialize<'de> for GeneratedField {
13655            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13656            where
13657                D: serde::Deserializer<'de>,
13658            {
13659                struct GeneratedVisitor;
13660
13661                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13662                    type Value = GeneratedField;
13663
13664                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13665                        write!(formatter, "expected one of: {:?}", &FIELDS)
13666                    }
13667
13668                    #[allow(unused_variables)]
13669                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13670                    where
13671                        E: serde::de::Error,
13672                    {
13673                        match value {
13674                            "progress" => Ok(GeneratedField::Progress),
13675                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13676                        }
13677                    }
13678                }
13679                deserializer.deserialize_identifier(GeneratedVisitor)
13680            }
13681        }
13682        struct GeneratedVisitor;
13683        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13684            type Value = subscribe_compaction_event_request::HeartBeat;
13685
13686            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13687                formatter.write_str("struct hummock.SubscribeCompactionEventRequest.HeartBeat")
13688            }
13689
13690            fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::HeartBeat, V::Error>
13691                where
13692                    V: serde::de::MapAccess<'de>,
13693            {
13694                let mut progress__ = None;
13695                while let Some(k) = map_.next_key()? {
13696                    match k {
13697                        GeneratedField::Progress => {
13698                            if progress__.is_some() {
13699                                return Err(serde::de::Error::duplicate_field("progress"));
13700                            }
13701                            progress__ = Some(map_.next_value()?);
13702                        }
13703                    }
13704                }
13705                Ok(subscribe_compaction_event_request::HeartBeat {
13706                    progress: progress__.unwrap_or_default(),
13707                })
13708            }
13709        }
13710        deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.HeartBeat", FIELDS, GeneratedVisitor)
13711    }
13712}
13713impl serde::Serialize for subscribe_compaction_event_request::PullTask {
13714    #[allow(deprecated)]
13715    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13716    where
13717        S: serde::Serializer,
13718    {
13719        use serde::ser::SerializeStruct;
13720        let mut len = 0;
13721        if self.pull_task_count != 0 {
13722            len += 1;
13723        }
13724        let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.PullTask", len)?;
13725        if self.pull_task_count != 0 {
13726            struct_ser.serialize_field("pullTaskCount", &self.pull_task_count)?;
13727        }
13728        struct_ser.end()
13729    }
13730}
13731impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::PullTask {
13732    #[allow(deprecated)]
13733    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13734    where
13735        D: serde::Deserializer<'de>,
13736    {
13737        const FIELDS: &[&str] = &[
13738            "pull_task_count",
13739            "pullTaskCount",
13740        ];
13741
13742        #[allow(clippy::enum_variant_names)]
13743        enum GeneratedField {
13744            PullTaskCount,
13745        }
13746        impl<'de> serde::Deserialize<'de> for GeneratedField {
13747            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13748            where
13749                D: serde::Deserializer<'de>,
13750            {
13751                struct GeneratedVisitor;
13752
13753                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13754                    type Value = GeneratedField;
13755
13756                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13757                        write!(formatter, "expected one of: {:?}", &FIELDS)
13758                    }
13759
13760                    #[allow(unused_variables)]
13761                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13762                    where
13763                        E: serde::de::Error,
13764                    {
13765                        match value {
13766                            "pullTaskCount" | "pull_task_count" => Ok(GeneratedField::PullTaskCount),
13767                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13768                        }
13769                    }
13770                }
13771                deserializer.deserialize_identifier(GeneratedVisitor)
13772            }
13773        }
13774        struct GeneratedVisitor;
13775        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13776            type Value = subscribe_compaction_event_request::PullTask;
13777
13778            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13779                formatter.write_str("struct hummock.SubscribeCompactionEventRequest.PullTask")
13780            }
13781
13782            fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::PullTask, V::Error>
13783                where
13784                    V: serde::de::MapAccess<'de>,
13785            {
13786                let mut pull_task_count__ = None;
13787                while let Some(k) = map_.next_key()? {
13788                    match k {
13789                        GeneratedField::PullTaskCount => {
13790                            if pull_task_count__.is_some() {
13791                                return Err(serde::de::Error::duplicate_field("pullTaskCount"));
13792                            }
13793                            pull_task_count__ = 
13794                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13795                            ;
13796                        }
13797                    }
13798                }
13799                Ok(subscribe_compaction_event_request::PullTask {
13800                    pull_task_count: pull_task_count__.unwrap_or_default(),
13801                })
13802            }
13803        }
13804        deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.PullTask", FIELDS, GeneratedVisitor)
13805    }
13806}
13807impl serde::Serialize for subscribe_compaction_event_request::Register {
13808    #[allow(deprecated)]
13809    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13810    where
13811        S: serde::Serializer,
13812    {
13813        use serde::ser::SerializeStruct;
13814        let mut len = 0;
13815        if self.context_id != 0 {
13816            len += 1;
13817        }
13818        let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.Register", len)?;
13819        if self.context_id != 0 {
13820            struct_ser.serialize_field("contextId", &self.context_id)?;
13821        }
13822        struct_ser.end()
13823    }
13824}
13825impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::Register {
13826    #[allow(deprecated)]
13827    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13828    where
13829        D: serde::Deserializer<'de>,
13830    {
13831        const FIELDS: &[&str] = &[
13832            "context_id",
13833            "contextId",
13834        ];
13835
13836        #[allow(clippy::enum_variant_names)]
13837        enum GeneratedField {
13838            ContextId,
13839        }
13840        impl<'de> serde::Deserialize<'de> for GeneratedField {
13841            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13842            where
13843                D: serde::Deserializer<'de>,
13844            {
13845                struct GeneratedVisitor;
13846
13847                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13848                    type Value = GeneratedField;
13849
13850                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13851                        write!(formatter, "expected one of: {:?}", &FIELDS)
13852                    }
13853
13854                    #[allow(unused_variables)]
13855                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13856                    where
13857                        E: serde::de::Error,
13858                    {
13859                        match value {
13860                            "contextId" | "context_id" => Ok(GeneratedField::ContextId),
13861                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13862                        }
13863                    }
13864                }
13865                deserializer.deserialize_identifier(GeneratedVisitor)
13866            }
13867        }
13868        struct GeneratedVisitor;
13869        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13870            type Value = subscribe_compaction_event_request::Register;
13871
13872            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13873                formatter.write_str("struct hummock.SubscribeCompactionEventRequest.Register")
13874            }
13875
13876            fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::Register, V::Error>
13877                where
13878                    V: serde::de::MapAccess<'de>,
13879            {
13880                let mut context_id__ = None;
13881                while let Some(k) = map_.next_key()? {
13882                    match k {
13883                        GeneratedField::ContextId => {
13884                            if context_id__.is_some() {
13885                                return Err(serde::de::Error::duplicate_field("contextId"));
13886                            }
13887                            context_id__ = 
13888                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13889                            ;
13890                        }
13891                    }
13892                }
13893                Ok(subscribe_compaction_event_request::Register {
13894                    context_id: context_id__.unwrap_or_default(),
13895                })
13896            }
13897        }
13898        deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.Register", FIELDS, GeneratedVisitor)
13899    }
13900}
13901impl serde::Serialize for subscribe_compaction_event_request::ReportTask {
13902    #[allow(deprecated)]
13903    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13904    where
13905        S: serde::Serializer,
13906    {
13907        use serde::ser::SerializeStruct;
13908        let mut len = 0;
13909        if !self.table_stats_change.is_empty() {
13910            len += 1;
13911        }
13912        if self.task_id != 0 {
13913            len += 1;
13914        }
13915        if self.task_status != 0 {
13916            len += 1;
13917        }
13918        if !self.sorted_output_ssts.is_empty() {
13919            len += 1;
13920        }
13921        if !self.object_timestamps.is_empty() {
13922            len += 1;
13923        }
13924        let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventRequest.ReportTask", len)?;
13925        if !self.table_stats_change.is_empty() {
13926            struct_ser.serialize_field("tableStatsChange", &self.table_stats_change)?;
13927        }
13928        if self.task_id != 0 {
13929            #[allow(clippy::needless_borrow)]
13930            #[allow(clippy::needless_borrows_for_generic_args)]
13931            struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
13932        }
13933        if self.task_status != 0 {
13934            let v = compact_task::TaskStatus::try_from(self.task_status)
13935                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.task_status)))?;
13936            struct_ser.serialize_field("taskStatus", &v)?;
13937        }
13938        if !self.sorted_output_ssts.is_empty() {
13939            struct_ser.serialize_field("sortedOutputSsts", &self.sorted_output_ssts)?;
13940        }
13941        if !self.object_timestamps.is_empty() {
13942            let v: std::collections::HashMap<_, _> = self.object_timestamps.iter()
13943                .map(|(k, v)| (k, v.to_string())).collect();
13944            struct_ser.serialize_field("objectTimestamps", &v)?;
13945        }
13946        struct_ser.end()
13947    }
13948}
13949impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_request::ReportTask {
13950    #[allow(deprecated)]
13951    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13952    where
13953        D: serde::Deserializer<'de>,
13954    {
13955        const FIELDS: &[&str] = &[
13956            "table_stats_change",
13957            "tableStatsChange",
13958            "task_id",
13959            "taskId",
13960            "task_status",
13961            "taskStatus",
13962            "sorted_output_ssts",
13963            "sortedOutputSsts",
13964            "object_timestamps",
13965            "objectTimestamps",
13966        ];
13967
13968        #[allow(clippy::enum_variant_names)]
13969        enum GeneratedField {
13970            TableStatsChange,
13971            TaskId,
13972            TaskStatus,
13973            SortedOutputSsts,
13974            ObjectTimestamps,
13975        }
13976        impl<'de> serde::Deserialize<'de> for GeneratedField {
13977            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13978            where
13979                D: serde::Deserializer<'de>,
13980            {
13981                struct GeneratedVisitor;
13982
13983                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13984                    type Value = GeneratedField;
13985
13986                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13987                        write!(formatter, "expected one of: {:?}", &FIELDS)
13988                    }
13989
13990                    #[allow(unused_variables)]
13991                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13992                    where
13993                        E: serde::de::Error,
13994                    {
13995                        match value {
13996                            "tableStatsChange" | "table_stats_change" => Ok(GeneratedField::TableStatsChange),
13997                            "taskId" | "task_id" => Ok(GeneratedField::TaskId),
13998                            "taskStatus" | "task_status" => Ok(GeneratedField::TaskStatus),
13999                            "sortedOutputSsts" | "sorted_output_ssts" => Ok(GeneratedField::SortedOutputSsts),
14000                            "objectTimestamps" | "object_timestamps" => Ok(GeneratedField::ObjectTimestamps),
14001                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14002                        }
14003                    }
14004                }
14005                deserializer.deserialize_identifier(GeneratedVisitor)
14006            }
14007        }
14008        struct GeneratedVisitor;
14009        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14010            type Value = subscribe_compaction_event_request::ReportTask;
14011
14012            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14013                formatter.write_str("struct hummock.SubscribeCompactionEventRequest.ReportTask")
14014            }
14015
14016            fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_request::ReportTask, V::Error>
14017                where
14018                    V: serde::de::MapAccess<'de>,
14019            {
14020                let mut table_stats_change__ = None;
14021                let mut task_id__ = None;
14022                let mut task_status__ = None;
14023                let mut sorted_output_ssts__ = None;
14024                let mut object_timestamps__ = None;
14025                while let Some(k) = map_.next_key()? {
14026                    match k {
14027                        GeneratedField::TableStatsChange => {
14028                            if table_stats_change__.is_some() {
14029                                return Err(serde::de::Error::duplicate_field("tableStatsChange"));
14030                            }
14031                            table_stats_change__ = Some(
14032                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14033                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
14034                            );
14035                        }
14036                        GeneratedField::TaskId => {
14037                            if task_id__.is_some() {
14038                                return Err(serde::de::Error::duplicate_field("taskId"));
14039                            }
14040                            task_id__ = 
14041                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14042                            ;
14043                        }
14044                        GeneratedField::TaskStatus => {
14045                            if task_status__.is_some() {
14046                                return Err(serde::de::Error::duplicate_field("taskStatus"));
14047                            }
14048                            task_status__ = Some(map_.next_value::<compact_task::TaskStatus>()? as i32);
14049                        }
14050                        GeneratedField::SortedOutputSsts => {
14051                            if sorted_output_ssts__.is_some() {
14052                                return Err(serde::de::Error::duplicate_field("sortedOutputSsts"));
14053                            }
14054                            sorted_output_ssts__ = Some(map_.next_value()?);
14055                        }
14056                        GeneratedField::ObjectTimestamps => {
14057                            if object_timestamps__.is_some() {
14058                                return Err(serde::de::Error::duplicate_field("objectTimestamps"));
14059                            }
14060                            object_timestamps__ = Some(
14061                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
14062                                    .into_iter().map(|(k,v)| (k.0, v.0)).collect()
14063                            );
14064                        }
14065                    }
14066                }
14067                Ok(subscribe_compaction_event_request::ReportTask {
14068                    table_stats_change: table_stats_change__.unwrap_or_default(),
14069                    task_id: task_id__.unwrap_or_default(),
14070                    task_status: task_status__.unwrap_or_default(),
14071                    sorted_output_ssts: sorted_output_ssts__.unwrap_or_default(),
14072                    object_timestamps: object_timestamps__.unwrap_or_default(),
14073                })
14074            }
14075        }
14076        deserializer.deserialize_struct("hummock.SubscribeCompactionEventRequest.ReportTask", FIELDS, GeneratedVisitor)
14077    }
14078}
14079impl serde::Serialize for SubscribeCompactionEventResponse {
14080    #[allow(deprecated)]
14081    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14082    where
14083        S: serde::Serializer,
14084    {
14085        use serde::ser::SerializeStruct;
14086        let mut len = 0;
14087        if self.create_at != 0 {
14088            len += 1;
14089        }
14090        if self.event.is_some() {
14091            len += 1;
14092        }
14093        let mut struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventResponse", len)?;
14094        if self.create_at != 0 {
14095            #[allow(clippy::needless_borrow)]
14096            #[allow(clippy::needless_borrows_for_generic_args)]
14097            struct_ser.serialize_field("createAt", ToString::to_string(&self.create_at).as_str())?;
14098        }
14099        if let Some(v) = self.event.as_ref() {
14100            match v {
14101                subscribe_compaction_event_response::Event::CompactTask(v) => {
14102                    struct_ser.serialize_field("compactTask", v)?;
14103                }
14104                subscribe_compaction_event_response::Event::VacuumTask(v) => {
14105                    struct_ser.serialize_field("vacuumTask", v)?;
14106                }
14107                subscribe_compaction_event_response::Event::FullScanTask(v) => {
14108                    struct_ser.serialize_field("fullScanTask", v)?;
14109                }
14110                subscribe_compaction_event_response::Event::ValidationTask(v) => {
14111                    struct_ser.serialize_field("validationTask", v)?;
14112                }
14113                subscribe_compaction_event_response::Event::CancelCompactTask(v) => {
14114                    struct_ser.serialize_field("cancelCompactTask", v)?;
14115                }
14116                subscribe_compaction_event_response::Event::PullTaskAck(v) => {
14117                    struct_ser.serialize_field("pullTaskAck", v)?;
14118                }
14119            }
14120        }
14121        struct_ser.end()
14122    }
14123}
14124impl<'de> serde::Deserialize<'de> for SubscribeCompactionEventResponse {
14125    #[allow(deprecated)]
14126    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14127    where
14128        D: serde::Deserializer<'de>,
14129    {
14130        const FIELDS: &[&str] = &[
14131            "create_at",
14132            "createAt",
14133            "compact_task",
14134            "compactTask",
14135            "vacuum_task",
14136            "vacuumTask",
14137            "full_scan_task",
14138            "fullScanTask",
14139            "validation_task",
14140            "validationTask",
14141            "cancel_compact_task",
14142            "cancelCompactTask",
14143            "pull_task_ack",
14144            "pullTaskAck",
14145        ];
14146
14147        #[allow(clippy::enum_variant_names)]
14148        enum GeneratedField {
14149            CreateAt,
14150            CompactTask,
14151            VacuumTask,
14152            FullScanTask,
14153            ValidationTask,
14154            CancelCompactTask,
14155            PullTaskAck,
14156        }
14157        impl<'de> serde::Deserialize<'de> for GeneratedField {
14158            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14159            where
14160                D: serde::Deserializer<'de>,
14161            {
14162                struct GeneratedVisitor;
14163
14164                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14165                    type Value = GeneratedField;
14166
14167                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14168                        write!(formatter, "expected one of: {:?}", &FIELDS)
14169                    }
14170
14171                    #[allow(unused_variables)]
14172                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14173                    where
14174                        E: serde::de::Error,
14175                    {
14176                        match value {
14177                            "createAt" | "create_at" => Ok(GeneratedField::CreateAt),
14178                            "compactTask" | "compact_task" => Ok(GeneratedField::CompactTask),
14179                            "vacuumTask" | "vacuum_task" => Ok(GeneratedField::VacuumTask),
14180                            "fullScanTask" | "full_scan_task" => Ok(GeneratedField::FullScanTask),
14181                            "validationTask" | "validation_task" => Ok(GeneratedField::ValidationTask),
14182                            "cancelCompactTask" | "cancel_compact_task" => Ok(GeneratedField::CancelCompactTask),
14183                            "pullTaskAck" | "pull_task_ack" => Ok(GeneratedField::PullTaskAck),
14184                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14185                        }
14186                    }
14187                }
14188                deserializer.deserialize_identifier(GeneratedVisitor)
14189            }
14190        }
14191        struct GeneratedVisitor;
14192        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14193            type Value = SubscribeCompactionEventResponse;
14194
14195            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14196                formatter.write_str("struct hummock.SubscribeCompactionEventResponse")
14197            }
14198
14199            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeCompactionEventResponse, V::Error>
14200                where
14201                    V: serde::de::MapAccess<'de>,
14202            {
14203                let mut create_at__ = None;
14204                let mut event__ = None;
14205                while let Some(k) = map_.next_key()? {
14206                    match k {
14207                        GeneratedField::CreateAt => {
14208                            if create_at__.is_some() {
14209                                return Err(serde::de::Error::duplicate_field("createAt"));
14210                            }
14211                            create_at__ = 
14212                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14213                            ;
14214                        }
14215                        GeneratedField::CompactTask => {
14216                            if event__.is_some() {
14217                                return Err(serde::de::Error::duplicate_field("compactTask"));
14218                            }
14219                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::CompactTask)
14220;
14221                        }
14222                        GeneratedField::VacuumTask => {
14223                            if event__.is_some() {
14224                                return Err(serde::de::Error::duplicate_field("vacuumTask"));
14225                            }
14226                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::VacuumTask)
14227;
14228                        }
14229                        GeneratedField::FullScanTask => {
14230                            if event__.is_some() {
14231                                return Err(serde::de::Error::duplicate_field("fullScanTask"));
14232                            }
14233                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::FullScanTask)
14234;
14235                        }
14236                        GeneratedField::ValidationTask => {
14237                            if event__.is_some() {
14238                                return Err(serde::de::Error::duplicate_field("validationTask"));
14239                            }
14240                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::ValidationTask)
14241;
14242                        }
14243                        GeneratedField::CancelCompactTask => {
14244                            if event__.is_some() {
14245                                return Err(serde::de::Error::duplicate_field("cancelCompactTask"));
14246                            }
14247                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::CancelCompactTask)
14248;
14249                        }
14250                        GeneratedField::PullTaskAck => {
14251                            if event__.is_some() {
14252                                return Err(serde::de::Error::duplicate_field("pullTaskAck"));
14253                            }
14254                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_compaction_event_response::Event::PullTaskAck)
14255;
14256                        }
14257                    }
14258                }
14259                Ok(SubscribeCompactionEventResponse {
14260                    create_at: create_at__.unwrap_or_default(),
14261                    event: event__,
14262                })
14263            }
14264        }
14265        deserializer.deserialize_struct("hummock.SubscribeCompactionEventResponse", FIELDS, GeneratedVisitor)
14266    }
14267}
14268impl serde::Serialize for subscribe_compaction_event_response::PullTaskAck {
14269    #[allow(deprecated)]
14270    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14271    where
14272        S: serde::Serializer,
14273    {
14274        use serde::ser::SerializeStruct;
14275        let len = 0;
14276        let struct_ser = serializer.serialize_struct("hummock.SubscribeCompactionEventResponse.PullTaskAck", len)?;
14277        struct_ser.end()
14278    }
14279}
14280impl<'de> serde::Deserialize<'de> for subscribe_compaction_event_response::PullTaskAck {
14281    #[allow(deprecated)]
14282    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14283    where
14284        D: serde::Deserializer<'de>,
14285    {
14286        const FIELDS: &[&str] = &[
14287        ];
14288
14289        #[allow(clippy::enum_variant_names)]
14290        enum GeneratedField {
14291        }
14292        impl<'de> serde::Deserialize<'de> for GeneratedField {
14293            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14294            where
14295                D: serde::Deserializer<'de>,
14296            {
14297                struct GeneratedVisitor;
14298
14299                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14300                    type Value = GeneratedField;
14301
14302                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14303                        write!(formatter, "expected one of: {:?}", &FIELDS)
14304                    }
14305
14306                    #[allow(unused_variables)]
14307                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14308                    where
14309                        E: serde::de::Error,
14310                    {
14311                            Err(serde::de::Error::unknown_field(value, FIELDS))
14312                    }
14313                }
14314                deserializer.deserialize_identifier(GeneratedVisitor)
14315            }
14316        }
14317        struct GeneratedVisitor;
14318        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14319            type Value = subscribe_compaction_event_response::PullTaskAck;
14320
14321            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14322                formatter.write_str("struct hummock.SubscribeCompactionEventResponse.PullTaskAck")
14323            }
14324
14325            fn visit_map<V>(self, mut map_: V) -> std::result::Result<subscribe_compaction_event_response::PullTaskAck, V::Error>
14326                where
14327                    V: serde::de::MapAccess<'de>,
14328            {
14329                while map_.next_key::<GeneratedField>()?.is_some() {
14330                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14331                }
14332                Ok(subscribe_compaction_event_response::PullTaskAck {
14333                })
14334            }
14335        }
14336        deserializer.deserialize_struct("hummock.SubscribeCompactionEventResponse.PullTaskAck", FIELDS, GeneratedVisitor)
14337    }
14338}
14339impl serde::Serialize for TableChangeLog {
14340    #[allow(deprecated)]
14341    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14342    where
14343        S: serde::Serializer,
14344    {
14345        use serde::ser::SerializeStruct;
14346        let mut len = 0;
14347        if !self.change_logs.is_empty() {
14348            len += 1;
14349        }
14350        let mut struct_ser = serializer.serialize_struct("hummock.TableChangeLog", len)?;
14351        if !self.change_logs.is_empty() {
14352            struct_ser.serialize_field("changeLogs", &self.change_logs)?;
14353        }
14354        struct_ser.end()
14355    }
14356}
14357impl<'de> serde::Deserialize<'de> for TableChangeLog {
14358    #[allow(deprecated)]
14359    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14360    where
14361        D: serde::Deserializer<'de>,
14362    {
14363        const FIELDS: &[&str] = &[
14364            "change_logs",
14365            "changeLogs",
14366        ];
14367
14368        #[allow(clippy::enum_variant_names)]
14369        enum GeneratedField {
14370            ChangeLogs,
14371        }
14372        impl<'de> serde::Deserialize<'de> for GeneratedField {
14373            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14374            where
14375                D: serde::Deserializer<'de>,
14376            {
14377                struct GeneratedVisitor;
14378
14379                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14380                    type Value = GeneratedField;
14381
14382                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14383                        write!(formatter, "expected one of: {:?}", &FIELDS)
14384                    }
14385
14386                    #[allow(unused_variables)]
14387                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14388                    where
14389                        E: serde::de::Error,
14390                    {
14391                        match value {
14392                            "changeLogs" | "change_logs" => Ok(GeneratedField::ChangeLogs),
14393                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14394                        }
14395                    }
14396                }
14397                deserializer.deserialize_identifier(GeneratedVisitor)
14398            }
14399        }
14400        struct GeneratedVisitor;
14401        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14402            type Value = TableChangeLog;
14403
14404            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14405                formatter.write_str("struct hummock.TableChangeLog")
14406            }
14407
14408            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableChangeLog, V::Error>
14409                where
14410                    V: serde::de::MapAccess<'de>,
14411            {
14412                let mut change_logs__ = None;
14413                while let Some(k) = map_.next_key()? {
14414                    match k {
14415                        GeneratedField::ChangeLogs => {
14416                            if change_logs__.is_some() {
14417                                return Err(serde::de::Error::duplicate_field("changeLogs"));
14418                            }
14419                            change_logs__ = Some(map_.next_value()?);
14420                        }
14421                    }
14422                }
14423                Ok(TableChangeLog {
14424                    change_logs: change_logs__.unwrap_or_default(),
14425                })
14426            }
14427        }
14428        deserializer.deserialize_struct("hummock.TableChangeLog", FIELDS, GeneratedVisitor)
14429    }
14430}
14431impl serde::Serialize for TableOption {
14432    #[allow(deprecated)]
14433    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14434    where
14435        S: serde::Serializer,
14436    {
14437        use serde::ser::SerializeStruct;
14438        let mut len = 0;
14439        if self.retention_seconds.is_some() {
14440            len += 1;
14441        }
14442        let mut struct_ser = serializer.serialize_struct("hummock.TableOption", len)?;
14443        if let Some(v) = self.retention_seconds.as_ref() {
14444            struct_ser.serialize_field("retentionSeconds", v)?;
14445        }
14446        struct_ser.end()
14447    }
14448}
14449impl<'de> serde::Deserialize<'de> for TableOption {
14450    #[allow(deprecated)]
14451    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14452    where
14453        D: serde::Deserializer<'de>,
14454    {
14455        const FIELDS: &[&str] = &[
14456            "retention_seconds",
14457            "retentionSeconds",
14458        ];
14459
14460        #[allow(clippy::enum_variant_names)]
14461        enum GeneratedField {
14462            RetentionSeconds,
14463        }
14464        impl<'de> serde::Deserialize<'de> for GeneratedField {
14465            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14466            where
14467                D: serde::Deserializer<'de>,
14468            {
14469                struct GeneratedVisitor;
14470
14471                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14472                    type Value = GeneratedField;
14473
14474                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14475                        write!(formatter, "expected one of: {:?}", &FIELDS)
14476                    }
14477
14478                    #[allow(unused_variables)]
14479                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14480                    where
14481                        E: serde::de::Error,
14482                    {
14483                        match value {
14484                            "retentionSeconds" | "retention_seconds" => Ok(GeneratedField::RetentionSeconds),
14485                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14486                        }
14487                    }
14488                }
14489                deserializer.deserialize_identifier(GeneratedVisitor)
14490            }
14491        }
14492        struct GeneratedVisitor;
14493        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14494            type Value = TableOption;
14495
14496            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14497                formatter.write_str("struct hummock.TableOption")
14498            }
14499
14500            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableOption, V::Error>
14501                where
14502                    V: serde::de::MapAccess<'de>,
14503            {
14504                let mut retention_seconds__ = None;
14505                while let Some(k) = map_.next_key()? {
14506                    match k {
14507                        GeneratedField::RetentionSeconds => {
14508                            if retention_seconds__.is_some() {
14509                                return Err(serde::de::Error::duplicate_field("retentionSeconds"));
14510                            }
14511                            retention_seconds__ = 
14512                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14513                            ;
14514                        }
14515                    }
14516                }
14517                Ok(TableOption {
14518                    retention_seconds: retention_seconds__,
14519                })
14520            }
14521        }
14522        deserializer.deserialize_struct("hummock.TableOption", FIELDS, GeneratedVisitor)
14523    }
14524}
14525impl serde::Serialize for TableSchema {
14526    #[allow(deprecated)]
14527    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14528    where
14529        S: serde::Serializer,
14530    {
14531        use serde::ser::SerializeStruct;
14532        let mut len = 0;
14533        if !self.column_ids.is_empty() {
14534            len += 1;
14535        }
14536        let mut struct_ser = serializer.serialize_struct("hummock.TableSchema", len)?;
14537        if !self.column_ids.is_empty() {
14538            struct_ser.serialize_field("columnIds", &self.column_ids)?;
14539        }
14540        struct_ser.end()
14541    }
14542}
14543impl<'de> serde::Deserialize<'de> for TableSchema {
14544    #[allow(deprecated)]
14545    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14546    where
14547        D: serde::Deserializer<'de>,
14548    {
14549        const FIELDS: &[&str] = &[
14550            "column_ids",
14551            "columnIds",
14552        ];
14553
14554        #[allow(clippy::enum_variant_names)]
14555        enum GeneratedField {
14556            ColumnIds,
14557        }
14558        impl<'de> serde::Deserialize<'de> for GeneratedField {
14559            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14560            where
14561                D: serde::Deserializer<'de>,
14562            {
14563                struct GeneratedVisitor;
14564
14565                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14566                    type Value = GeneratedField;
14567
14568                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14569                        write!(formatter, "expected one of: {:?}", &FIELDS)
14570                    }
14571
14572                    #[allow(unused_variables)]
14573                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14574                    where
14575                        E: serde::de::Error,
14576                    {
14577                        match value {
14578                            "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
14579                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14580                        }
14581                    }
14582                }
14583                deserializer.deserialize_identifier(GeneratedVisitor)
14584            }
14585        }
14586        struct GeneratedVisitor;
14587        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14588            type Value = TableSchema;
14589
14590            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14591                formatter.write_str("struct hummock.TableSchema")
14592            }
14593
14594            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableSchema, V::Error>
14595                where
14596                    V: serde::de::MapAccess<'de>,
14597            {
14598                let mut column_ids__ = None;
14599                while let Some(k) = map_.next_key()? {
14600                    match k {
14601                        GeneratedField::ColumnIds => {
14602                            if column_ids__.is_some() {
14603                                return Err(serde::de::Error::duplicate_field("columnIds"));
14604                            }
14605                            column_ids__ = 
14606                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14607                                    .into_iter().map(|x| x.0).collect())
14608                            ;
14609                        }
14610                    }
14611                }
14612                Ok(TableSchema {
14613                    column_ids: column_ids__.unwrap_or_default(),
14614                })
14615            }
14616        }
14617        deserializer.deserialize_struct("hummock.TableSchema", FIELDS, GeneratedVisitor)
14618    }
14619}
14620impl serde::Serialize for TableStats {
14621    #[allow(deprecated)]
14622    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14623    where
14624        S: serde::Serializer,
14625    {
14626        use serde::ser::SerializeStruct;
14627        let mut len = 0;
14628        if self.total_key_size != 0 {
14629            len += 1;
14630        }
14631        if self.total_value_size != 0 {
14632            len += 1;
14633        }
14634        if self.total_key_count != 0 {
14635            len += 1;
14636        }
14637        if self.total_compressed_size != 0 {
14638            len += 1;
14639        }
14640        let mut struct_ser = serializer.serialize_struct("hummock.TableStats", len)?;
14641        if self.total_key_size != 0 {
14642            #[allow(clippy::needless_borrow)]
14643            #[allow(clippy::needless_borrows_for_generic_args)]
14644            struct_ser.serialize_field("totalKeySize", ToString::to_string(&self.total_key_size).as_str())?;
14645        }
14646        if self.total_value_size != 0 {
14647            #[allow(clippy::needless_borrow)]
14648            #[allow(clippy::needless_borrows_for_generic_args)]
14649            struct_ser.serialize_field("totalValueSize", ToString::to_string(&self.total_value_size).as_str())?;
14650        }
14651        if self.total_key_count != 0 {
14652            #[allow(clippy::needless_borrow)]
14653            #[allow(clippy::needless_borrows_for_generic_args)]
14654            struct_ser.serialize_field("totalKeyCount", ToString::to_string(&self.total_key_count).as_str())?;
14655        }
14656        if self.total_compressed_size != 0 {
14657            #[allow(clippy::needless_borrow)]
14658            #[allow(clippy::needless_borrows_for_generic_args)]
14659            struct_ser.serialize_field("totalCompressedSize", ToString::to_string(&self.total_compressed_size).as_str())?;
14660        }
14661        struct_ser.end()
14662    }
14663}
14664impl<'de> serde::Deserialize<'de> for TableStats {
14665    #[allow(deprecated)]
14666    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14667    where
14668        D: serde::Deserializer<'de>,
14669    {
14670        const FIELDS: &[&str] = &[
14671            "total_key_size",
14672            "totalKeySize",
14673            "total_value_size",
14674            "totalValueSize",
14675            "total_key_count",
14676            "totalKeyCount",
14677            "total_compressed_size",
14678            "totalCompressedSize",
14679        ];
14680
14681        #[allow(clippy::enum_variant_names)]
14682        enum GeneratedField {
14683            TotalKeySize,
14684            TotalValueSize,
14685            TotalKeyCount,
14686            TotalCompressedSize,
14687        }
14688        impl<'de> serde::Deserialize<'de> for GeneratedField {
14689            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14690            where
14691                D: serde::Deserializer<'de>,
14692            {
14693                struct GeneratedVisitor;
14694
14695                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14696                    type Value = GeneratedField;
14697
14698                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14699                        write!(formatter, "expected one of: {:?}", &FIELDS)
14700                    }
14701
14702                    #[allow(unused_variables)]
14703                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14704                    where
14705                        E: serde::de::Error,
14706                    {
14707                        match value {
14708                            "totalKeySize" | "total_key_size" => Ok(GeneratedField::TotalKeySize),
14709                            "totalValueSize" | "total_value_size" => Ok(GeneratedField::TotalValueSize),
14710                            "totalKeyCount" | "total_key_count" => Ok(GeneratedField::TotalKeyCount),
14711                            "totalCompressedSize" | "total_compressed_size" => Ok(GeneratedField::TotalCompressedSize),
14712                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14713                        }
14714                    }
14715                }
14716                deserializer.deserialize_identifier(GeneratedVisitor)
14717            }
14718        }
14719        struct GeneratedVisitor;
14720        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14721            type Value = TableStats;
14722
14723            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14724                formatter.write_str("struct hummock.TableStats")
14725            }
14726
14727            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableStats, V::Error>
14728                where
14729                    V: serde::de::MapAccess<'de>,
14730            {
14731                let mut total_key_size__ = None;
14732                let mut total_value_size__ = None;
14733                let mut total_key_count__ = None;
14734                let mut total_compressed_size__ = None;
14735                while let Some(k) = map_.next_key()? {
14736                    match k {
14737                        GeneratedField::TotalKeySize => {
14738                            if total_key_size__.is_some() {
14739                                return Err(serde::de::Error::duplicate_field("totalKeySize"));
14740                            }
14741                            total_key_size__ = 
14742                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14743                            ;
14744                        }
14745                        GeneratedField::TotalValueSize => {
14746                            if total_value_size__.is_some() {
14747                                return Err(serde::de::Error::duplicate_field("totalValueSize"));
14748                            }
14749                            total_value_size__ = 
14750                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14751                            ;
14752                        }
14753                        GeneratedField::TotalKeyCount => {
14754                            if total_key_count__.is_some() {
14755                                return Err(serde::de::Error::duplicate_field("totalKeyCount"));
14756                            }
14757                            total_key_count__ = 
14758                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14759                            ;
14760                        }
14761                        GeneratedField::TotalCompressedSize => {
14762                            if total_compressed_size__.is_some() {
14763                                return Err(serde::de::Error::duplicate_field("totalCompressedSize"));
14764                            }
14765                            total_compressed_size__ = 
14766                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14767                            ;
14768                        }
14769                    }
14770                }
14771                Ok(TableStats {
14772                    total_key_size: total_key_size__.unwrap_or_default(),
14773                    total_value_size: total_value_size__.unwrap_or_default(),
14774                    total_key_count: total_key_count__.unwrap_or_default(),
14775                    total_compressed_size: total_compressed_size__.unwrap_or_default(),
14776                })
14777            }
14778        }
14779        deserializer.deserialize_struct("hummock.TableStats", FIELDS, GeneratedVisitor)
14780    }
14781}
14782impl serde::Serialize for TableWatermarks {
14783    #[allow(deprecated)]
14784    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14785    where
14786        S: serde::Serializer,
14787    {
14788        use serde::ser::SerializeStruct;
14789        let mut len = 0;
14790        if !self.epoch_watermarks.is_empty() {
14791            len += 1;
14792        }
14793        if self.is_ascending {
14794            len += 1;
14795        }
14796        if self.is_non_pk_prefix {
14797            len += 1;
14798        }
14799        let mut struct_ser = serializer.serialize_struct("hummock.TableWatermarks", len)?;
14800        if !self.epoch_watermarks.is_empty() {
14801            struct_ser.serialize_field("epochWatermarks", &self.epoch_watermarks)?;
14802        }
14803        if self.is_ascending {
14804            struct_ser.serialize_field("isAscending", &self.is_ascending)?;
14805        }
14806        if self.is_non_pk_prefix {
14807            struct_ser.serialize_field("isNonPkPrefix", &self.is_non_pk_prefix)?;
14808        }
14809        struct_ser.end()
14810    }
14811}
14812impl<'de> serde::Deserialize<'de> for TableWatermarks {
14813    #[allow(deprecated)]
14814    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14815    where
14816        D: serde::Deserializer<'de>,
14817    {
14818        const FIELDS: &[&str] = &[
14819            "epoch_watermarks",
14820            "epochWatermarks",
14821            "is_ascending",
14822            "isAscending",
14823            "is_non_pk_prefix",
14824            "isNonPkPrefix",
14825        ];
14826
14827        #[allow(clippy::enum_variant_names)]
14828        enum GeneratedField {
14829            EpochWatermarks,
14830            IsAscending,
14831            IsNonPkPrefix,
14832        }
14833        impl<'de> serde::Deserialize<'de> for GeneratedField {
14834            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14835            where
14836                D: serde::Deserializer<'de>,
14837            {
14838                struct GeneratedVisitor;
14839
14840                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14841                    type Value = GeneratedField;
14842
14843                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14844                        write!(formatter, "expected one of: {:?}", &FIELDS)
14845                    }
14846
14847                    #[allow(unused_variables)]
14848                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14849                    where
14850                        E: serde::de::Error,
14851                    {
14852                        match value {
14853                            "epochWatermarks" | "epoch_watermarks" => Ok(GeneratedField::EpochWatermarks),
14854                            "isAscending" | "is_ascending" => Ok(GeneratedField::IsAscending),
14855                            "isNonPkPrefix" | "is_non_pk_prefix" => Ok(GeneratedField::IsNonPkPrefix),
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 = TableWatermarks;
14866
14867            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14868                formatter.write_str("struct hummock.TableWatermarks")
14869            }
14870
14871            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableWatermarks, V::Error>
14872                where
14873                    V: serde::de::MapAccess<'de>,
14874            {
14875                let mut epoch_watermarks__ = None;
14876                let mut is_ascending__ = None;
14877                let mut is_non_pk_prefix__ = None;
14878                while let Some(k) = map_.next_key()? {
14879                    match k {
14880                        GeneratedField::EpochWatermarks => {
14881                            if epoch_watermarks__.is_some() {
14882                                return Err(serde::de::Error::duplicate_field("epochWatermarks"));
14883                            }
14884                            epoch_watermarks__ = Some(map_.next_value()?);
14885                        }
14886                        GeneratedField::IsAscending => {
14887                            if is_ascending__.is_some() {
14888                                return Err(serde::de::Error::duplicate_field("isAscending"));
14889                            }
14890                            is_ascending__ = Some(map_.next_value()?);
14891                        }
14892                        GeneratedField::IsNonPkPrefix => {
14893                            if is_non_pk_prefix__.is_some() {
14894                                return Err(serde::de::Error::duplicate_field("isNonPkPrefix"));
14895                            }
14896                            is_non_pk_prefix__ = Some(map_.next_value()?);
14897                        }
14898                    }
14899                }
14900                Ok(TableWatermarks {
14901                    epoch_watermarks: epoch_watermarks__.unwrap_or_default(),
14902                    is_ascending: is_ascending__.unwrap_or_default(),
14903                    is_non_pk_prefix: is_non_pk_prefix__.unwrap_or_default(),
14904                })
14905            }
14906        }
14907        deserializer.deserialize_struct("hummock.TableWatermarks", FIELDS, GeneratedVisitor)
14908    }
14909}
14910impl serde::Serialize for table_watermarks::EpochNewWatermarks {
14911    #[allow(deprecated)]
14912    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14913    where
14914        S: serde::Serializer,
14915    {
14916        use serde::ser::SerializeStruct;
14917        let mut len = 0;
14918        if !self.watermarks.is_empty() {
14919            len += 1;
14920        }
14921        if self.epoch != 0 {
14922            len += 1;
14923        }
14924        let mut struct_ser = serializer.serialize_struct("hummock.TableWatermarks.EpochNewWatermarks", len)?;
14925        if !self.watermarks.is_empty() {
14926            struct_ser.serialize_field("watermarks", &self.watermarks)?;
14927        }
14928        if self.epoch != 0 {
14929            #[allow(clippy::needless_borrow)]
14930            #[allow(clippy::needless_borrows_for_generic_args)]
14931            struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
14932        }
14933        struct_ser.end()
14934    }
14935}
14936impl<'de> serde::Deserialize<'de> for table_watermarks::EpochNewWatermarks {
14937    #[allow(deprecated)]
14938    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14939    where
14940        D: serde::Deserializer<'de>,
14941    {
14942        const FIELDS: &[&str] = &[
14943            "watermarks",
14944            "epoch",
14945        ];
14946
14947        #[allow(clippy::enum_variant_names)]
14948        enum GeneratedField {
14949            Watermarks,
14950            Epoch,
14951        }
14952        impl<'de> serde::Deserialize<'de> for GeneratedField {
14953            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14954            where
14955                D: serde::Deserializer<'de>,
14956            {
14957                struct GeneratedVisitor;
14958
14959                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14960                    type Value = GeneratedField;
14961
14962                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14963                        write!(formatter, "expected one of: {:?}", &FIELDS)
14964                    }
14965
14966                    #[allow(unused_variables)]
14967                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14968                    where
14969                        E: serde::de::Error,
14970                    {
14971                        match value {
14972                            "watermarks" => Ok(GeneratedField::Watermarks),
14973                            "epoch" => Ok(GeneratedField::Epoch),
14974                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14975                        }
14976                    }
14977                }
14978                deserializer.deserialize_identifier(GeneratedVisitor)
14979            }
14980        }
14981        struct GeneratedVisitor;
14982        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14983            type Value = table_watermarks::EpochNewWatermarks;
14984
14985            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14986                formatter.write_str("struct hummock.TableWatermarks.EpochNewWatermarks")
14987            }
14988
14989            fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_watermarks::EpochNewWatermarks, V::Error>
14990                where
14991                    V: serde::de::MapAccess<'de>,
14992            {
14993                let mut watermarks__ = None;
14994                let mut epoch__ = None;
14995                while let Some(k) = map_.next_key()? {
14996                    match k {
14997                        GeneratedField::Watermarks => {
14998                            if watermarks__.is_some() {
14999                                return Err(serde::de::Error::duplicate_field("watermarks"));
15000                            }
15001                            watermarks__ = Some(map_.next_value()?);
15002                        }
15003                        GeneratedField::Epoch => {
15004                            if epoch__.is_some() {
15005                                return Err(serde::de::Error::duplicate_field("epoch"));
15006                            }
15007                            epoch__ = 
15008                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15009                            ;
15010                        }
15011                    }
15012                }
15013                Ok(table_watermarks::EpochNewWatermarks {
15014                    watermarks: watermarks__.unwrap_or_default(),
15015                    epoch: epoch__.unwrap_or_default(),
15016                })
15017            }
15018        }
15019        deserializer.deserialize_struct("hummock.TableWatermarks.EpochNewWatermarks", FIELDS, GeneratedVisitor)
15020    }
15021}
15022impl serde::Serialize for TriggerCompactionDeterministicRequest {
15023    #[allow(deprecated)]
15024    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15025    where
15026        S: serde::Serializer,
15027    {
15028        use serde::ser::SerializeStruct;
15029        let mut len = 0;
15030        if self.version_id != 0 {
15031            len += 1;
15032        }
15033        if !self.compaction_groups.is_empty() {
15034            len += 1;
15035        }
15036        let mut struct_ser = serializer.serialize_struct("hummock.TriggerCompactionDeterministicRequest", len)?;
15037        if self.version_id != 0 {
15038            #[allow(clippy::needless_borrow)]
15039            #[allow(clippy::needless_borrows_for_generic_args)]
15040            struct_ser.serialize_field("versionId", ToString::to_string(&self.version_id).as_str())?;
15041        }
15042        if !self.compaction_groups.is_empty() {
15043            struct_ser.serialize_field("compactionGroups", &self.compaction_groups.iter().map(ToString::to_string).collect::<Vec<_>>())?;
15044        }
15045        struct_ser.end()
15046    }
15047}
15048impl<'de> serde::Deserialize<'de> for TriggerCompactionDeterministicRequest {
15049    #[allow(deprecated)]
15050    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15051    where
15052        D: serde::Deserializer<'de>,
15053    {
15054        const FIELDS: &[&str] = &[
15055            "version_id",
15056            "versionId",
15057            "compaction_groups",
15058            "compactionGroups",
15059        ];
15060
15061        #[allow(clippy::enum_variant_names)]
15062        enum GeneratedField {
15063            VersionId,
15064            CompactionGroups,
15065        }
15066        impl<'de> serde::Deserialize<'de> for GeneratedField {
15067            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15068            where
15069                D: serde::Deserializer<'de>,
15070            {
15071                struct GeneratedVisitor;
15072
15073                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15074                    type Value = GeneratedField;
15075
15076                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15077                        write!(formatter, "expected one of: {:?}", &FIELDS)
15078                    }
15079
15080                    #[allow(unused_variables)]
15081                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15082                    where
15083                        E: serde::de::Error,
15084                    {
15085                        match value {
15086                            "versionId" | "version_id" => Ok(GeneratedField::VersionId),
15087                            "compactionGroups" | "compaction_groups" => Ok(GeneratedField::CompactionGroups),
15088                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15089                        }
15090                    }
15091                }
15092                deserializer.deserialize_identifier(GeneratedVisitor)
15093            }
15094        }
15095        struct GeneratedVisitor;
15096        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15097            type Value = TriggerCompactionDeterministicRequest;
15098
15099            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15100                formatter.write_str("struct hummock.TriggerCompactionDeterministicRequest")
15101            }
15102
15103            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerCompactionDeterministicRequest, V::Error>
15104                where
15105                    V: serde::de::MapAccess<'de>,
15106            {
15107                let mut version_id__ = None;
15108                let mut compaction_groups__ = None;
15109                while let Some(k) = map_.next_key()? {
15110                    match k {
15111                        GeneratedField::VersionId => {
15112                            if version_id__.is_some() {
15113                                return Err(serde::de::Error::duplicate_field("versionId"));
15114                            }
15115                            version_id__ = 
15116                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15117                            ;
15118                        }
15119                        GeneratedField::CompactionGroups => {
15120                            if compaction_groups__.is_some() {
15121                                return Err(serde::de::Error::duplicate_field("compactionGroups"));
15122                            }
15123                            compaction_groups__ = 
15124                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15125                                    .into_iter().map(|x| x.0).collect())
15126                            ;
15127                        }
15128                    }
15129                }
15130                Ok(TriggerCompactionDeterministicRequest {
15131                    version_id: version_id__.unwrap_or_default(),
15132                    compaction_groups: compaction_groups__.unwrap_or_default(),
15133                })
15134            }
15135        }
15136        deserializer.deserialize_struct("hummock.TriggerCompactionDeterministicRequest", FIELDS, GeneratedVisitor)
15137    }
15138}
15139impl serde::Serialize for TriggerCompactionDeterministicResponse {
15140    #[allow(deprecated)]
15141    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15142    where
15143        S: serde::Serializer,
15144    {
15145        use serde::ser::SerializeStruct;
15146        let len = 0;
15147        let struct_ser = serializer.serialize_struct("hummock.TriggerCompactionDeterministicResponse", len)?;
15148        struct_ser.end()
15149    }
15150}
15151impl<'de> serde::Deserialize<'de> for TriggerCompactionDeterministicResponse {
15152    #[allow(deprecated)]
15153    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15154    where
15155        D: serde::Deserializer<'de>,
15156    {
15157        const FIELDS: &[&str] = &[
15158        ];
15159
15160        #[allow(clippy::enum_variant_names)]
15161        enum GeneratedField {
15162        }
15163        impl<'de> serde::Deserialize<'de> for GeneratedField {
15164            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15165            where
15166                D: serde::Deserializer<'de>,
15167            {
15168                struct GeneratedVisitor;
15169
15170                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15171                    type Value = GeneratedField;
15172
15173                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15174                        write!(formatter, "expected one of: {:?}", &FIELDS)
15175                    }
15176
15177                    #[allow(unused_variables)]
15178                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15179                    where
15180                        E: serde::de::Error,
15181                    {
15182                            Err(serde::de::Error::unknown_field(value, FIELDS))
15183                    }
15184                }
15185                deserializer.deserialize_identifier(GeneratedVisitor)
15186            }
15187        }
15188        struct GeneratedVisitor;
15189        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15190            type Value = TriggerCompactionDeterministicResponse;
15191
15192            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15193                formatter.write_str("struct hummock.TriggerCompactionDeterministicResponse")
15194            }
15195
15196            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerCompactionDeterministicResponse, V::Error>
15197                where
15198                    V: serde::de::MapAccess<'de>,
15199            {
15200                while map_.next_key::<GeneratedField>()?.is_some() {
15201                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
15202                }
15203                Ok(TriggerCompactionDeterministicResponse {
15204                })
15205            }
15206        }
15207        deserializer.deserialize_struct("hummock.TriggerCompactionDeterministicResponse", FIELDS, GeneratedVisitor)
15208    }
15209}
15210impl serde::Serialize for TriggerFullGcRequest {
15211    #[allow(deprecated)]
15212    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15213    where
15214        S: serde::Serializer,
15215    {
15216        use serde::ser::SerializeStruct;
15217        let mut len = 0;
15218        if self.sst_retention_time_sec != 0 {
15219            len += 1;
15220        }
15221        if self.prefix.is_some() {
15222            len += 1;
15223        }
15224        let mut struct_ser = serializer.serialize_struct("hummock.TriggerFullGCRequest", len)?;
15225        if self.sst_retention_time_sec != 0 {
15226            #[allow(clippy::needless_borrow)]
15227            #[allow(clippy::needless_borrows_for_generic_args)]
15228            struct_ser.serialize_field("sstRetentionTimeSec", ToString::to_string(&self.sst_retention_time_sec).as_str())?;
15229        }
15230        if let Some(v) = self.prefix.as_ref() {
15231            struct_ser.serialize_field("prefix", v)?;
15232        }
15233        struct_ser.end()
15234    }
15235}
15236impl<'de> serde::Deserialize<'de> for TriggerFullGcRequest {
15237    #[allow(deprecated)]
15238    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15239    where
15240        D: serde::Deserializer<'de>,
15241    {
15242        const FIELDS: &[&str] = &[
15243            "sst_retention_time_sec",
15244            "sstRetentionTimeSec",
15245            "prefix",
15246        ];
15247
15248        #[allow(clippy::enum_variant_names)]
15249        enum GeneratedField {
15250            SstRetentionTimeSec,
15251            Prefix,
15252        }
15253        impl<'de> serde::Deserialize<'de> for GeneratedField {
15254            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15255            where
15256                D: serde::Deserializer<'de>,
15257            {
15258                struct GeneratedVisitor;
15259
15260                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15261                    type Value = GeneratedField;
15262
15263                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15264                        write!(formatter, "expected one of: {:?}", &FIELDS)
15265                    }
15266
15267                    #[allow(unused_variables)]
15268                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15269                    where
15270                        E: serde::de::Error,
15271                    {
15272                        match value {
15273                            "sstRetentionTimeSec" | "sst_retention_time_sec" => Ok(GeneratedField::SstRetentionTimeSec),
15274                            "prefix" => Ok(GeneratedField::Prefix),
15275                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15276                        }
15277                    }
15278                }
15279                deserializer.deserialize_identifier(GeneratedVisitor)
15280            }
15281        }
15282        struct GeneratedVisitor;
15283        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15284            type Value = TriggerFullGcRequest;
15285
15286            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15287                formatter.write_str("struct hummock.TriggerFullGCRequest")
15288            }
15289
15290            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerFullGcRequest, V::Error>
15291                where
15292                    V: serde::de::MapAccess<'de>,
15293            {
15294                let mut sst_retention_time_sec__ = None;
15295                let mut prefix__ = None;
15296                while let Some(k) = map_.next_key()? {
15297                    match k {
15298                        GeneratedField::SstRetentionTimeSec => {
15299                            if sst_retention_time_sec__.is_some() {
15300                                return Err(serde::de::Error::duplicate_field("sstRetentionTimeSec"));
15301                            }
15302                            sst_retention_time_sec__ = 
15303                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15304                            ;
15305                        }
15306                        GeneratedField::Prefix => {
15307                            if prefix__.is_some() {
15308                                return Err(serde::de::Error::duplicate_field("prefix"));
15309                            }
15310                            prefix__ = map_.next_value()?;
15311                        }
15312                    }
15313                }
15314                Ok(TriggerFullGcRequest {
15315                    sst_retention_time_sec: sst_retention_time_sec__.unwrap_or_default(),
15316                    prefix: prefix__,
15317                })
15318            }
15319        }
15320        deserializer.deserialize_struct("hummock.TriggerFullGCRequest", FIELDS, GeneratedVisitor)
15321    }
15322}
15323impl serde::Serialize for TriggerFullGcResponse {
15324    #[allow(deprecated)]
15325    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15326    where
15327        S: serde::Serializer,
15328    {
15329        use serde::ser::SerializeStruct;
15330        let mut len = 0;
15331        if self.status.is_some() {
15332            len += 1;
15333        }
15334        let mut struct_ser = serializer.serialize_struct("hummock.TriggerFullGCResponse", len)?;
15335        if let Some(v) = self.status.as_ref() {
15336            struct_ser.serialize_field("status", v)?;
15337        }
15338        struct_ser.end()
15339    }
15340}
15341impl<'de> serde::Deserialize<'de> for TriggerFullGcResponse {
15342    #[allow(deprecated)]
15343    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15344    where
15345        D: serde::Deserializer<'de>,
15346    {
15347        const FIELDS: &[&str] = &[
15348            "status",
15349        ];
15350
15351        #[allow(clippy::enum_variant_names)]
15352        enum GeneratedField {
15353            Status,
15354        }
15355        impl<'de> serde::Deserialize<'de> for GeneratedField {
15356            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15357            where
15358                D: serde::Deserializer<'de>,
15359            {
15360                struct GeneratedVisitor;
15361
15362                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15363                    type Value = GeneratedField;
15364
15365                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15366                        write!(formatter, "expected one of: {:?}", &FIELDS)
15367                    }
15368
15369                    #[allow(unused_variables)]
15370                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15371                    where
15372                        E: serde::de::Error,
15373                    {
15374                        match value {
15375                            "status" => Ok(GeneratedField::Status),
15376                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15377                        }
15378                    }
15379                }
15380                deserializer.deserialize_identifier(GeneratedVisitor)
15381            }
15382        }
15383        struct GeneratedVisitor;
15384        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15385            type Value = TriggerFullGcResponse;
15386
15387            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15388                formatter.write_str("struct hummock.TriggerFullGCResponse")
15389            }
15390
15391            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerFullGcResponse, V::Error>
15392                where
15393                    V: serde::de::MapAccess<'de>,
15394            {
15395                let mut status__ = None;
15396                while let Some(k) = map_.next_key()? {
15397                    match k {
15398                        GeneratedField::Status => {
15399                            if status__.is_some() {
15400                                return Err(serde::de::Error::duplicate_field("status"));
15401                            }
15402                            status__ = map_.next_value()?;
15403                        }
15404                    }
15405                }
15406                Ok(TriggerFullGcResponse {
15407                    status: status__,
15408                })
15409            }
15410        }
15411        deserializer.deserialize_struct("hummock.TriggerFullGCResponse", FIELDS, GeneratedVisitor)
15412    }
15413}
15414impl serde::Serialize for TriggerManualCompactionRequest {
15415    #[allow(deprecated)]
15416    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15417    where
15418        S: serde::Serializer,
15419    {
15420        use serde::ser::SerializeStruct;
15421        let mut len = 0;
15422        if self.compaction_group_id != 0 {
15423            len += 1;
15424        }
15425        if self.key_range.is_some() {
15426            len += 1;
15427        }
15428        if self.table_id != 0 {
15429            len += 1;
15430        }
15431        if self.level != 0 {
15432            len += 1;
15433        }
15434        if !self.sst_ids.is_empty() {
15435            len += 1;
15436        }
15437        let mut struct_ser = serializer.serialize_struct("hummock.TriggerManualCompactionRequest", len)?;
15438        if self.compaction_group_id != 0 {
15439            #[allow(clippy::needless_borrow)]
15440            #[allow(clippy::needless_borrows_for_generic_args)]
15441            struct_ser.serialize_field("compactionGroupId", ToString::to_string(&self.compaction_group_id).as_str())?;
15442        }
15443        if let Some(v) = self.key_range.as_ref() {
15444            struct_ser.serialize_field("keyRange", v)?;
15445        }
15446        if self.table_id != 0 {
15447            struct_ser.serialize_field("tableId", &self.table_id)?;
15448        }
15449        if self.level != 0 {
15450            struct_ser.serialize_field("level", &self.level)?;
15451        }
15452        if !self.sst_ids.is_empty() {
15453            struct_ser.serialize_field("sstIds", &self.sst_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
15454        }
15455        struct_ser.end()
15456    }
15457}
15458impl<'de> serde::Deserialize<'de> for TriggerManualCompactionRequest {
15459    #[allow(deprecated)]
15460    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15461    where
15462        D: serde::Deserializer<'de>,
15463    {
15464        const FIELDS: &[&str] = &[
15465            "compaction_group_id",
15466            "compactionGroupId",
15467            "key_range",
15468            "keyRange",
15469            "table_id",
15470            "tableId",
15471            "level",
15472            "sst_ids",
15473            "sstIds",
15474        ];
15475
15476        #[allow(clippy::enum_variant_names)]
15477        enum GeneratedField {
15478            CompactionGroupId,
15479            KeyRange,
15480            TableId,
15481            Level,
15482            SstIds,
15483        }
15484        impl<'de> serde::Deserialize<'de> for GeneratedField {
15485            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15486            where
15487                D: serde::Deserializer<'de>,
15488            {
15489                struct GeneratedVisitor;
15490
15491                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15492                    type Value = GeneratedField;
15493
15494                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15495                        write!(formatter, "expected one of: {:?}", &FIELDS)
15496                    }
15497
15498                    #[allow(unused_variables)]
15499                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15500                    where
15501                        E: serde::de::Error,
15502                    {
15503                        match value {
15504                            "compactionGroupId" | "compaction_group_id" => Ok(GeneratedField::CompactionGroupId),
15505                            "keyRange" | "key_range" => Ok(GeneratedField::KeyRange),
15506                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
15507                            "level" => Ok(GeneratedField::Level),
15508                            "sstIds" | "sst_ids" => Ok(GeneratedField::SstIds),
15509                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15510                        }
15511                    }
15512                }
15513                deserializer.deserialize_identifier(GeneratedVisitor)
15514            }
15515        }
15516        struct GeneratedVisitor;
15517        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15518            type Value = TriggerManualCompactionRequest;
15519
15520            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15521                formatter.write_str("struct hummock.TriggerManualCompactionRequest")
15522            }
15523
15524            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerManualCompactionRequest, V::Error>
15525                where
15526                    V: serde::de::MapAccess<'de>,
15527            {
15528                let mut compaction_group_id__ = None;
15529                let mut key_range__ = None;
15530                let mut table_id__ = None;
15531                let mut level__ = None;
15532                let mut sst_ids__ = None;
15533                while let Some(k) = map_.next_key()? {
15534                    match k {
15535                        GeneratedField::CompactionGroupId => {
15536                            if compaction_group_id__.is_some() {
15537                                return Err(serde::de::Error::duplicate_field("compactionGroupId"));
15538                            }
15539                            compaction_group_id__ = 
15540                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15541                            ;
15542                        }
15543                        GeneratedField::KeyRange => {
15544                            if key_range__.is_some() {
15545                                return Err(serde::de::Error::duplicate_field("keyRange"));
15546                            }
15547                            key_range__ = map_.next_value()?;
15548                        }
15549                        GeneratedField::TableId => {
15550                            if table_id__.is_some() {
15551                                return Err(serde::de::Error::duplicate_field("tableId"));
15552                            }
15553                            table_id__ = 
15554                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15555                            ;
15556                        }
15557                        GeneratedField::Level => {
15558                            if level__.is_some() {
15559                                return Err(serde::de::Error::duplicate_field("level"));
15560                            }
15561                            level__ = 
15562                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15563                            ;
15564                        }
15565                        GeneratedField::SstIds => {
15566                            if sst_ids__.is_some() {
15567                                return Err(serde::de::Error::duplicate_field("sstIds"));
15568                            }
15569                            sst_ids__ = 
15570                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15571                                    .into_iter().map(|x| x.0).collect())
15572                            ;
15573                        }
15574                    }
15575                }
15576                Ok(TriggerManualCompactionRequest {
15577                    compaction_group_id: compaction_group_id__.unwrap_or_default(),
15578                    key_range: key_range__,
15579                    table_id: table_id__.unwrap_or_default(),
15580                    level: level__.unwrap_or_default(),
15581                    sst_ids: sst_ids__.unwrap_or_default(),
15582                })
15583            }
15584        }
15585        deserializer.deserialize_struct("hummock.TriggerManualCompactionRequest", FIELDS, GeneratedVisitor)
15586    }
15587}
15588impl serde::Serialize for TriggerManualCompactionResponse {
15589    #[allow(deprecated)]
15590    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15591    where
15592        S: serde::Serializer,
15593    {
15594        use serde::ser::SerializeStruct;
15595        let mut len = 0;
15596        if self.status.is_some() {
15597            len += 1;
15598        }
15599        let mut struct_ser = serializer.serialize_struct("hummock.TriggerManualCompactionResponse", len)?;
15600        if let Some(v) = self.status.as_ref() {
15601            struct_ser.serialize_field("status", v)?;
15602        }
15603        struct_ser.end()
15604    }
15605}
15606impl<'de> serde::Deserialize<'de> for TriggerManualCompactionResponse {
15607    #[allow(deprecated)]
15608    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15609    where
15610        D: serde::Deserializer<'de>,
15611    {
15612        const FIELDS: &[&str] = &[
15613            "status",
15614        ];
15615
15616        #[allow(clippy::enum_variant_names)]
15617        enum GeneratedField {
15618            Status,
15619        }
15620        impl<'de> serde::Deserialize<'de> for GeneratedField {
15621            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15622            where
15623                D: serde::Deserializer<'de>,
15624            {
15625                struct GeneratedVisitor;
15626
15627                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15628                    type Value = GeneratedField;
15629
15630                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15631                        write!(formatter, "expected one of: {:?}", &FIELDS)
15632                    }
15633
15634                    #[allow(unused_variables)]
15635                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15636                    where
15637                        E: serde::de::Error,
15638                    {
15639                        match value {
15640                            "status" => Ok(GeneratedField::Status),
15641                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15642                        }
15643                    }
15644                }
15645                deserializer.deserialize_identifier(GeneratedVisitor)
15646            }
15647        }
15648        struct GeneratedVisitor;
15649        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15650            type Value = TriggerManualCompactionResponse;
15651
15652            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15653                formatter.write_str("struct hummock.TriggerManualCompactionResponse")
15654            }
15655
15656            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TriggerManualCompactionResponse, V::Error>
15657                where
15658                    V: serde::de::MapAccess<'de>,
15659            {
15660                let mut status__ = None;
15661                while let Some(k) = map_.next_key()? {
15662                    match k {
15663                        GeneratedField::Status => {
15664                            if status__.is_some() {
15665                                return Err(serde::de::Error::duplicate_field("status"));
15666                            }
15667                            status__ = map_.next_value()?;
15668                        }
15669                    }
15670                }
15671                Ok(TriggerManualCompactionResponse {
15672                    status: status__,
15673                })
15674            }
15675        }
15676        deserializer.deserialize_struct("hummock.TriggerManualCompactionResponse", FIELDS, GeneratedVisitor)
15677    }
15678}
15679impl serde::Serialize for UnpinVersionBeforeRequest {
15680    #[allow(deprecated)]
15681    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15682    where
15683        S: serde::Serializer,
15684    {
15685        use serde::ser::SerializeStruct;
15686        let mut len = 0;
15687        if self.context_id != 0 {
15688            len += 1;
15689        }
15690        if self.unpin_version_before != 0 {
15691            len += 1;
15692        }
15693        let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionBeforeRequest", len)?;
15694        if self.context_id != 0 {
15695            struct_ser.serialize_field("contextId", &self.context_id)?;
15696        }
15697        if self.unpin_version_before != 0 {
15698            #[allow(clippy::needless_borrow)]
15699            #[allow(clippy::needless_borrows_for_generic_args)]
15700            struct_ser.serialize_field("unpinVersionBefore", ToString::to_string(&self.unpin_version_before).as_str())?;
15701        }
15702        struct_ser.end()
15703    }
15704}
15705impl<'de> serde::Deserialize<'de> for UnpinVersionBeforeRequest {
15706    #[allow(deprecated)]
15707    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15708    where
15709        D: serde::Deserializer<'de>,
15710    {
15711        const FIELDS: &[&str] = &[
15712            "context_id",
15713            "contextId",
15714            "unpin_version_before",
15715            "unpinVersionBefore",
15716        ];
15717
15718        #[allow(clippy::enum_variant_names)]
15719        enum GeneratedField {
15720            ContextId,
15721            UnpinVersionBefore,
15722        }
15723        impl<'de> serde::Deserialize<'de> for GeneratedField {
15724            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15725            where
15726                D: serde::Deserializer<'de>,
15727            {
15728                struct GeneratedVisitor;
15729
15730                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15731                    type Value = GeneratedField;
15732
15733                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15734                        write!(formatter, "expected one of: {:?}", &FIELDS)
15735                    }
15736
15737                    #[allow(unused_variables)]
15738                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15739                    where
15740                        E: serde::de::Error,
15741                    {
15742                        match value {
15743                            "contextId" | "context_id" => Ok(GeneratedField::ContextId),
15744                            "unpinVersionBefore" | "unpin_version_before" => Ok(GeneratedField::UnpinVersionBefore),
15745                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15746                        }
15747                    }
15748                }
15749                deserializer.deserialize_identifier(GeneratedVisitor)
15750            }
15751        }
15752        struct GeneratedVisitor;
15753        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15754            type Value = UnpinVersionBeforeRequest;
15755
15756            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15757                formatter.write_str("struct hummock.UnpinVersionBeforeRequest")
15758            }
15759
15760            fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionBeforeRequest, V::Error>
15761                where
15762                    V: serde::de::MapAccess<'de>,
15763            {
15764                let mut context_id__ = None;
15765                let mut unpin_version_before__ = None;
15766                while let Some(k) = map_.next_key()? {
15767                    match k {
15768                        GeneratedField::ContextId => {
15769                            if context_id__.is_some() {
15770                                return Err(serde::de::Error::duplicate_field("contextId"));
15771                            }
15772                            context_id__ = 
15773                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15774                            ;
15775                        }
15776                        GeneratedField::UnpinVersionBefore => {
15777                            if unpin_version_before__.is_some() {
15778                                return Err(serde::de::Error::duplicate_field("unpinVersionBefore"));
15779                            }
15780                            unpin_version_before__ = 
15781                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15782                            ;
15783                        }
15784                    }
15785                }
15786                Ok(UnpinVersionBeforeRequest {
15787                    context_id: context_id__.unwrap_or_default(),
15788                    unpin_version_before: unpin_version_before__.unwrap_or_default(),
15789                })
15790            }
15791        }
15792        deserializer.deserialize_struct("hummock.UnpinVersionBeforeRequest", FIELDS, GeneratedVisitor)
15793    }
15794}
15795impl serde::Serialize for UnpinVersionBeforeResponse {
15796    #[allow(deprecated)]
15797    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15798    where
15799        S: serde::Serializer,
15800    {
15801        use serde::ser::SerializeStruct;
15802        let mut len = 0;
15803        if self.status.is_some() {
15804            len += 1;
15805        }
15806        let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionBeforeResponse", len)?;
15807        if let Some(v) = self.status.as_ref() {
15808            struct_ser.serialize_field("status", v)?;
15809        }
15810        struct_ser.end()
15811    }
15812}
15813impl<'de> serde::Deserialize<'de> for UnpinVersionBeforeResponse {
15814    #[allow(deprecated)]
15815    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15816    where
15817        D: serde::Deserializer<'de>,
15818    {
15819        const FIELDS: &[&str] = &[
15820            "status",
15821        ];
15822
15823        #[allow(clippy::enum_variant_names)]
15824        enum GeneratedField {
15825            Status,
15826        }
15827        impl<'de> serde::Deserialize<'de> for GeneratedField {
15828            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15829            where
15830                D: serde::Deserializer<'de>,
15831            {
15832                struct GeneratedVisitor;
15833
15834                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15835                    type Value = GeneratedField;
15836
15837                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15838                        write!(formatter, "expected one of: {:?}", &FIELDS)
15839                    }
15840
15841                    #[allow(unused_variables)]
15842                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15843                    where
15844                        E: serde::de::Error,
15845                    {
15846                        match value {
15847                            "status" => Ok(GeneratedField::Status),
15848                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15849                        }
15850                    }
15851                }
15852                deserializer.deserialize_identifier(GeneratedVisitor)
15853            }
15854        }
15855        struct GeneratedVisitor;
15856        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15857            type Value = UnpinVersionBeforeResponse;
15858
15859            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15860                formatter.write_str("struct hummock.UnpinVersionBeforeResponse")
15861            }
15862
15863            fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionBeforeResponse, V::Error>
15864                where
15865                    V: serde::de::MapAccess<'de>,
15866            {
15867                let mut status__ = None;
15868                while let Some(k) = map_.next_key()? {
15869                    match k {
15870                        GeneratedField::Status => {
15871                            if status__.is_some() {
15872                                return Err(serde::de::Error::duplicate_field("status"));
15873                            }
15874                            status__ = map_.next_value()?;
15875                        }
15876                    }
15877                }
15878                Ok(UnpinVersionBeforeResponse {
15879                    status: status__,
15880                })
15881            }
15882        }
15883        deserializer.deserialize_struct("hummock.UnpinVersionBeforeResponse", FIELDS, GeneratedVisitor)
15884    }
15885}
15886impl serde::Serialize for UnpinVersionRequest {
15887    #[allow(deprecated)]
15888    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15889    where
15890        S: serde::Serializer,
15891    {
15892        use serde::ser::SerializeStruct;
15893        let mut len = 0;
15894        if self.context_id != 0 {
15895            len += 1;
15896        }
15897        let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionRequest", len)?;
15898        if self.context_id != 0 {
15899            struct_ser.serialize_field("contextId", &self.context_id)?;
15900        }
15901        struct_ser.end()
15902    }
15903}
15904impl<'de> serde::Deserialize<'de> for UnpinVersionRequest {
15905    #[allow(deprecated)]
15906    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15907    where
15908        D: serde::Deserializer<'de>,
15909    {
15910        const FIELDS: &[&str] = &[
15911            "context_id",
15912            "contextId",
15913        ];
15914
15915        #[allow(clippy::enum_variant_names)]
15916        enum GeneratedField {
15917            ContextId,
15918        }
15919        impl<'de> serde::Deserialize<'de> for GeneratedField {
15920            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15921            where
15922                D: serde::Deserializer<'de>,
15923            {
15924                struct GeneratedVisitor;
15925
15926                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15927                    type Value = GeneratedField;
15928
15929                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15930                        write!(formatter, "expected one of: {:?}", &FIELDS)
15931                    }
15932
15933                    #[allow(unused_variables)]
15934                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15935                    where
15936                        E: serde::de::Error,
15937                    {
15938                        match value {
15939                            "contextId" | "context_id" => Ok(GeneratedField::ContextId),
15940                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15941                        }
15942                    }
15943                }
15944                deserializer.deserialize_identifier(GeneratedVisitor)
15945            }
15946        }
15947        struct GeneratedVisitor;
15948        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15949            type Value = UnpinVersionRequest;
15950
15951            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15952                formatter.write_str("struct hummock.UnpinVersionRequest")
15953            }
15954
15955            fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionRequest, V::Error>
15956                where
15957                    V: serde::de::MapAccess<'de>,
15958            {
15959                let mut context_id__ = None;
15960                while let Some(k) = map_.next_key()? {
15961                    match k {
15962                        GeneratedField::ContextId => {
15963                            if context_id__.is_some() {
15964                                return Err(serde::de::Error::duplicate_field("contextId"));
15965                            }
15966                            context_id__ = 
15967                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15968                            ;
15969                        }
15970                    }
15971                }
15972                Ok(UnpinVersionRequest {
15973                    context_id: context_id__.unwrap_or_default(),
15974                })
15975            }
15976        }
15977        deserializer.deserialize_struct("hummock.UnpinVersionRequest", FIELDS, GeneratedVisitor)
15978    }
15979}
15980impl serde::Serialize for UnpinVersionResponse {
15981    #[allow(deprecated)]
15982    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15983    where
15984        S: serde::Serializer,
15985    {
15986        use serde::ser::SerializeStruct;
15987        let mut len = 0;
15988        if self.status.is_some() {
15989            len += 1;
15990        }
15991        let mut struct_ser = serializer.serialize_struct("hummock.UnpinVersionResponse", len)?;
15992        if let Some(v) = self.status.as_ref() {
15993            struct_ser.serialize_field("status", v)?;
15994        }
15995        struct_ser.end()
15996    }
15997}
15998impl<'de> serde::Deserialize<'de> for UnpinVersionResponse {
15999    #[allow(deprecated)]
16000    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16001    where
16002        D: serde::Deserializer<'de>,
16003    {
16004        const FIELDS: &[&str] = &[
16005            "status",
16006        ];
16007
16008        #[allow(clippy::enum_variant_names)]
16009        enum GeneratedField {
16010            Status,
16011        }
16012        impl<'de> serde::Deserialize<'de> for GeneratedField {
16013            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16014            where
16015                D: serde::Deserializer<'de>,
16016            {
16017                struct GeneratedVisitor;
16018
16019                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16020                    type Value = GeneratedField;
16021
16022                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16023                        write!(formatter, "expected one of: {:?}", &FIELDS)
16024                    }
16025
16026                    #[allow(unused_variables)]
16027                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16028                    where
16029                        E: serde::de::Error,
16030                    {
16031                        match value {
16032                            "status" => Ok(GeneratedField::Status),
16033                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16034                        }
16035                    }
16036                }
16037                deserializer.deserialize_identifier(GeneratedVisitor)
16038            }
16039        }
16040        struct GeneratedVisitor;
16041        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16042            type Value = UnpinVersionResponse;
16043
16044            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16045                formatter.write_str("struct hummock.UnpinVersionResponse")
16046            }
16047
16048            fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnpinVersionResponse, V::Error>
16049                where
16050                    V: serde::de::MapAccess<'de>,
16051            {
16052                let mut status__ = None;
16053                while let Some(k) = map_.next_key()? {
16054                    match k {
16055                        GeneratedField::Status => {
16056                            if status__.is_some() {
16057                                return Err(serde::de::Error::duplicate_field("status"));
16058                            }
16059                            status__ = map_.next_value()?;
16060                        }
16061                    }
16062                }
16063                Ok(UnpinVersionResponse {
16064                    status: status__,
16065                })
16066            }
16067        }
16068        deserializer.deserialize_struct("hummock.UnpinVersionResponse", FIELDS, GeneratedVisitor)
16069    }
16070}
16071impl serde::Serialize for VacuumTask {
16072    #[allow(deprecated)]
16073    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16074    where
16075        S: serde::Serializer,
16076    {
16077        use serde::ser::SerializeStruct;
16078        let mut len = 0;
16079        if !self.sstable_object_ids.is_empty() {
16080            len += 1;
16081        }
16082        let mut struct_ser = serializer.serialize_struct("hummock.VacuumTask", len)?;
16083        if !self.sstable_object_ids.is_empty() {
16084            struct_ser.serialize_field("sstableObjectIds", &self.sstable_object_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
16085        }
16086        struct_ser.end()
16087    }
16088}
16089impl<'de> serde::Deserialize<'de> for VacuumTask {
16090    #[allow(deprecated)]
16091    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16092    where
16093        D: serde::Deserializer<'de>,
16094    {
16095        const FIELDS: &[&str] = &[
16096            "sstable_object_ids",
16097            "sstableObjectIds",
16098        ];
16099
16100        #[allow(clippy::enum_variant_names)]
16101        enum GeneratedField {
16102            SstableObjectIds,
16103        }
16104        impl<'de> serde::Deserialize<'de> for GeneratedField {
16105            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16106            where
16107                D: serde::Deserializer<'de>,
16108            {
16109                struct GeneratedVisitor;
16110
16111                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16112                    type Value = GeneratedField;
16113
16114                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16115                        write!(formatter, "expected one of: {:?}", &FIELDS)
16116                    }
16117
16118                    #[allow(unused_variables)]
16119                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16120                    where
16121                        E: serde::de::Error,
16122                    {
16123                        match value {
16124                            "sstableObjectIds" | "sstable_object_ids" => Ok(GeneratedField::SstableObjectIds),
16125                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16126                        }
16127                    }
16128                }
16129                deserializer.deserialize_identifier(GeneratedVisitor)
16130            }
16131        }
16132        struct GeneratedVisitor;
16133        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16134            type Value = VacuumTask;
16135
16136            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16137                formatter.write_str("struct hummock.VacuumTask")
16138            }
16139
16140            fn visit_map<V>(self, mut map_: V) -> std::result::Result<VacuumTask, V::Error>
16141                where
16142                    V: serde::de::MapAccess<'de>,
16143            {
16144                let mut sstable_object_ids__ = None;
16145                while let Some(k) = map_.next_key()? {
16146                    match k {
16147                        GeneratedField::SstableObjectIds => {
16148                            if sstable_object_ids__.is_some() {
16149                                return Err(serde::de::Error::duplicate_field("sstableObjectIds"));
16150                            }
16151                            sstable_object_ids__ = 
16152                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16153                                    .into_iter().map(|x| x.0).collect())
16154                            ;
16155                        }
16156                    }
16157                }
16158                Ok(VacuumTask {
16159                    sstable_object_ids: sstable_object_ids__.unwrap_or_default(),
16160                })
16161            }
16162        }
16163        deserializer.deserialize_struct("hummock.VacuumTask", FIELDS, GeneratedVisitor)
16164    }
16165}
16166impl serde::Serialize for ValidationTask {
16167    #[allow(deprecated)]
16168    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16169    where
16170        S: serde::Serializer,
16171    {
16172        use serde::ser::SerializeStruct;
16173        let mut len = 0;
16174        if !self.sst_infos.is_empty() {
16175            len += 1;
16176        }
16177        if !self.sst_id_to_worker_id.is_empty() {
16178            len += 1;
16179        }
16180        let mut struct_ser = serializer.serialize_struct("hummock.ValidationTask", len)?;
16181        if !self.sst_infos.is_empty() {
16182            struct_ser.serialize_field("sstInfos", &self.sst_infos)?;
16183        }
16184        if !self.sst_id_to_worker_id.is_empty() {
16185            struct_ser.serialize_field("sstIdToWorkerId", &self.sst_id_to_worker_id)?;
16186        }
16187        struct_ser.end()
16188    }
16189}
16190impl<'de> serde::Deserialize<'de> for ValidationTask {
16191    #[allow(deprecated)]
16192    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16193    where
16194        D: serde::Deserializer<'de>,
16195    {
16196        const FIELDS: &[&str] = &[
16197            "sst_infos",
16198            "sstInfos",
16199            "sst_id_to_worker_id",
16200            "sstIdToWorkerId",
16201        ];
16202
16203        #[allow(clippy::enum_variant_names)]
16204        enum GeneratedField {
16205            SstInfos,
16206            SstIdToWorkerId,
16207        }
16208        impl<'de> serde::Deserialize<'de> for GeneratedField {
16209            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16210            where
16211                D: serde::Deserializer<'de>,
16212            {
16213                struct GeneratedVisitor;
16214
16215                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16216                    type Value = GeneratedField;
16217
16218                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16219                        write!(formatter, "expected one of: {:?}", &FIELDS)
16220                    }
16221
16222                    #[allow(unused_variables)]
16223                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16224                    where
16225                        E: serde::de::Error,
16226                    {
16227                        match value {
16228                            "sstInfos" | "sst_infos" => Ok(GeneratedField::SstInfos),
16229                            "sstIdToWorkerId" | "sst_id_to_worker_id" => Ok(GeneratedField::SstIdToWorkerId),
16230                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16231                        }
16232                    }
16233                }
16234                deserializer.deserialize_identifier(GeneratedVisitor)
16235            }
16236        }
16237        struct GeneratedVisitor;
16238        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16239            type Value = ValidationTask;
16240
16241            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16242                formatter.write_str("struct hummock.ValidationTask")
16243            }
16244
16245            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValidationTask, V::Error>
16246                where
16247                    V: serde::de::MapAccess<'de>,
16248            {
16249                let mut sst_infos__ = None;
16250                let mut sst_id_to_worker_id__ = None;
16251                while let Some(k) = map_.next_key()? {
16252                    match k {
16253                        GeneratedField::SstInfos => {
16254                            if sst_infos__.is_some() {
16255                                return Err(serde::de::Error::duplicate_field("sstInfos"));
16256                            }
16257                            sst_infos__ = Some(map_.next_value()?);
16258                        }
16259                        GeneratedField::SstIdToWorkerId => {
16260                            if sst_id_to_worker_id__.is_some() {
16261                                return Err(serde::de::Error::duplicate_field("sstIdToWorkerId"));
16262                            }
16263                            sst_id_to_worker_id__ = Some(
16264                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u32>>>()?
16265                                    .into_iter().map(|(k,v)| (k.0, v.0)).collect()
16266                            );
16267                        }
16268                    }
16269                }
16270                Ok(ValidationTask {
16271                    sst_infos: sst_infos__.unwrap_or_default(),
16272                    sst_id_to_worker_id: sst_id_to_worker_id__.unwrap_or_default(),
16273                })
16274            }
16275        }
16276        deserializer.deserialize_struct("hummock.ValidationTask", FIELDS, GeneratedVisitor)
16277    }
16278}
16279impl serde::Serialize for VectorFileInfo {
16280    #[allow(deprecated)]
16281    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16282    where
16283        S: serde::Serializer,
16284    {
16285        use serde::ser::SerializeStruct;
16286        let mut len = 0;
16287        if self.object_id != 0 {
16288            len += 1;
16289        }
16290        if self.file_size != 0 {
16291            len += 1;
16292        }
16293        if self.start_vector_id != 0 {
16294            len += 1;
16295        }
16296        if self.vector_count != 0 {
16297            len += 1;
16298        }
16299        if self.meta_offset != 0 {
16300            len += 1;
16301        }
16302        let mut struct_ser = serializer.serialize_struct("hummock.VectorFileInfo", len)?;
16303        if self.object_id != 0 {
16304            #[allow(clippy::needless_borrow)]
16305            #[allow(clippy::needless_borrows_for_generic_args)]
16306            struct_ser.serialize_field("objectId", ToString::to_string(&self.object_id).as_str())?;
16307        }
16308        if self.file_size != 0 {
16309            #[allow(clippy::needless_borrow)]
16310            #[allow(clippy::needless_borrows_for_generic_args)]
16311            struct_ser.serialize_field("fileSize", ToString::to_string(&self.file_size).as_str())?;
16312        }
16313        if self.start_vector_id != 0 {
16314            #[allow(clippy::needless_borrow)]
16315            #[allow(clippy::needless_borrows_for_generic_args)]
16316            struct_ser.serialize_field("startVectorId", ToString::to_string(&self.start_vector_id).as_str())?;
16317        }
16318        if self.vector_count != 0 {
16319            struct_ser.serialize_field("vectorCount", &self.vector_count)?;
16320        }
16321        if self.meta_offset != 0 {
16322            #[allow(clippy::needless_borrow)]
16323            #[allow(clippy::needless_borrows_for_generic_args)]
16324            struct_ser.serialize_field("metaOffset", ToString::to_string(&self.meta_offset).as_str())?;
16325        }
16326        struct_ser.end()
16327    }
16328}
16329impl<'de> serde::Deserialize<'de> for VectorFileInfo {
16330    #[allow(deprecated)]
16331    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16332    where
16333        D: serde::Deserializer<'de>,
16334    {
16335        const FIELDS: &[&str] = &[
16336            "object_id",
16337            "objectId",
16338            "file_size",
16339            "fileSize",
16340            "start_vector_id",
16341            "startVectorId",
16342            "vector_count",
16343            "vectorCount",
16344            "meta_offset",
16345            "metaOffset",
16346        ];
16347
16348        #[allow(clippy::enum_variant_names)]
16349        enum GeneratedField {
16350            ObjectId,
16351            FileSize,
16352            StartVectorId,
16353            VectorCount,
16354            MetaOffset,
16355        }
16356        impl<'de> serde::Deserialize<'de> for GeneratedField {
16357            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16358            where
16359                D: serde::Deserializer<'de>,
16360            {
16361                struct GeneratedVisitor;
16362
16363                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16364                    type Value = GeneratedField;
16365
16366                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16367                        write!(formatter, "expected one of: {:?}", &FIELDS)
16368                    }
16369
16370                    #[allow(unused_variables)]
16371                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16372                    where
16373                        E: serde::de::Error,
16374                    {
16375                        match value {
16376                            "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
16377                            "fileSize" | "file_size" => Ok(GeneratedField::FileSize),
16378                            "startVectorId" | "start_vector_id" => Ok(GeneratedField::StartVectorId),
16379                            "vectorCount" | "vector_count" => Ok(GeneratedField::VectorCount),
16380                            "metaOffset" | "meta_offset" => Ok(GeneratedField::MetaOffset),
16381                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16382                        }
16383                    }
16384                }
16385                deserializer.deserialize_identifier(GeneratedVisitor)
16386            }
16387        }
16388        struct GeneratedVisitor;
16389        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16390            type Value = VectorFileInfo;
16391
16392            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16393                formatter.write_str("struct hummock.VectorFileInfo")
16394            }
16395
16396            fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorFileInfo, V::Error>
16397                where
16398                    V: serde::de::MapAccess<'de>,
16399            {
16400                let mut object_id__ = None;
16401                let mut file_size__ = None;
16402                let mut start_vector_id__ = None;
16403                let mut vector_count__ = None;
16404                let mut meta_offset__ = None;
16405                while let Some(k) = map_.next_key()? {
16406                    match k {
16407                        GeneratedField::ObjectId => {
16408                            if object_id__.is_some() {
16409                                return Err(serde::de::Error::duplicate_field("objectId"));
16410                            }
16411                            object_id__ = 
16412                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16413                            ;
16414                        }
16415                        GeneratedField::FileSize => {
16416                            if file_size__.is_some() {
16417                                return Err(serde::de::Error::duplicate_field("fileSize"));
16418                            }
16419                            file_size__ = 
16420                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16421                            ;
16422                        }
16423                        GeneratedField::StartVectorId => {
16424                            if start_vector_id__.is_some() {
16425                                return Err(serde::de::Error::duplicate_field("startVectorId"));
16426                            }
16427                            start_vector_id__ = 
16428                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16429                            ;
16430                        }
16431                        GeneratedField::VectorCount => {
16432                            if vector_count__.is_some() {
16433                                return Err(serde::de::Error::duplicate_field("vectorCount"));
16434                            }
16435                            vector_count__ = 
16436                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16437                            ;
16438                        }
16439                        GeneratedField::MetaOffset => {
16440                            if meta_offset__.is_some() {
16441                                return Err(serde::de::Error::duplicate_field("metaOffset"));
16442                            }
16443                            meta_offset__ = 
16444                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16445                            ;
16446                        }
16447                    }
16448                }
16449                Ok(VectorFileInfo {
16450                    object_id: object_id__.unwrap_or_default(),
16451                    file_size: file_size__.unwrap_or_default(),
16452                    start_vector_id: start_vector_id__.unwrap_or_default(),
16453                    vector_count: vector_count__.unwrap_or_default(),
16454                    meta_offset: meta_offset__.unwrap_or_default(),
16455                })
16456            }
16457        }
16458        deserializer.deserialize_struct("hummock.VectorFileInfo", FIELDS, GeneratedVisitor)
16459    }
16460}
16461impl serde::Serialize for VectorIndex {
16462    #[allow(deprecated)]
16463    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16464    where
16465        S: serde::Serializer,
16466    {
16467        use serde::ser::SerializeStruct;
16468        let mut len = 0;
16469        if self.dimension != 0 {
16470            len += 1;
16471        }
16472        if self.distance_type != 0 {
16473            len += 1;
16474        }
16475        if self.variant.is_some() {
16476            len += 1;
16477        }
16478        let mut struct_ser = serializer.serialize_struct("hummock.VectorIndex", len)?;
16479        if self.dimension != 0 {
16480            struct_ser.serialize_field("dimension", &self.dimension)?;
16481        }
16482        if self.distance_type != 0 {
16483            let v = DistanceType::try_from(self.distance_type)
16484                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distance_type)))?;
16485            struct_ser.serialize_field("distanceType", &v)?;
16486        }
16487        if let Some(v) = self.variant.as_ref() {
16488            match v {
16489                vector_index::Variant::Flat(v) => {
16490                    struct_ser.serialize_field("flat", v)?;
16491                }
16492            }
16493        }
16494        struct_ser.end()
16495    }
16496}
16497impl<'de> serde::Deserialize<'de> for VectorIndex {
16498    #[allow(deprecated)]
16499    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16500    where
16501        D: serde::Deserializer<'de>,
16502    {
16503        const FIELDS: &[&str] = &[
16504            "dimension",
16505            "distance_type",
16506            "distanceType",
16507            "flat",
16508        ];
16509
16510        #[allow(clippy::enum_variant_names)]
16511        enum GeneratedField {
16512            Dimension,
16513            DistanceType,
16514            Flat,
16515        }
16516        impl<'de> serde::Deserialize<'de> for GeneratedField {
16517            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16518            where
16519                D: serde::Deserializer<'de>,
16520            {
16521                struct GeneratedVisitor;
16522
16523                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16524                    type Value = GeneratedField;
16525
16526                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16527                        write!(formatter, "expected one of: {:?}", &FIELDS)
16528                    }
16529
16530                    #[allow(unused_variables)]
16531                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16532                    where
16533                        E: serde::de::Error,
16534                    {
16535                        match value {
16536                            "dimension" => Ok(GeneratedField::Dimension),
16537                            "distanceType" | "distance_type" => Ok(GeneratedField::DistanceType),
16538                            "flat" => Ok(GeneratedField::Flat),
16539                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16540                        }
16541                    }
16542                }
16543                deserializer.deserialize_identifier(GeneratedVisitor)
16544            }
16545        }
16546        struct GeneratedVisitor;
16547        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16548            type Value = VectorIndex;
16549
16550            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16551                formatter.write_str("struct hummock.VectorIndex")
16552            }
16553
16554            fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndex, V::Error>
16555                where
16556                    V: serde::de::MapAccess<'de>,
16557            {
16558                let mut dimension__ = None;
16559                let mut distance_type__ = None;
16560                let mut variant__ = None;
16561                while let Some(k) = map_.next_key()? {
16562                    match k {
16563                        GeneratedField::Dimension => {
16564                            if dimension__.is_some() {
16565                                return Err(serde::de::Error::duplicate_field("dimension"));
16566                            }
16567                            dimension__ = 
16568                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16569                            ;
16570                        }
16571                        GeneratedField::DistanceType => {
16572                            if distance_type__.is_some() {
16573                                return Err(serde::de::Error::duplicate_field("distanceType"));
16574                            }
16575                            distance_type__ = Some(map_.next_value::<DistanceType>()? as i32);
16576                        }
16577                        GeneratedField::Flat => {
16578                            if variant__.is_some() {
16579                                return Err(serde::de::Error::duplicate_field("flat"));
16580                            }
16581                            variant__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index::Variant::Flat)
16582;
16583                        }
16584                    }
16585                }
16586                Ok(VectorIndex {
16587                    dimension: dimension__.unwrap_or_default(),
16588                    distance_type: distance_type__.unwrap_or_default(),
16589                    variant: variant__,
16590                })
16591            }
16592        }
16593        deserializer.deserialize_struct("hummock.VectorIndex", FIELDS, GeneratedVisitor)
16594    }
16595}
16596impl serde::Serialize for VectorIndexDelta {
16597    #[allow(deprecated)]
16598    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16599    where
16600        S: serde::Serializer,
16601    {
16602        use serde::ser::SerializeStruct;
16603        let mut len = 0;
16604        if self.delta.is_some() {
16605            len += 1;
16606        }
16607        let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta", len)?;
16608        if let Some(v) = self.delta.as_ref() {
16609            match v {
16610                vector_index_delta::Delta::Init(v) => {
16611                    struct_ser.serialize_field("init", v)?;
16612                }
16613                vector_index_delta::Delta::Adds(v) => {
16614                    struct_ser.serialize_field("adds", v)?;
16615                }
16616            }
16617        }
16618        struct_ser.end()
16619    }
16620}
16621impl<'de> serde::Deserialize<'de> for VectorIndexDelta {
16622    #[allow(deprecated)]
16623    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16624    where
16625        D: serde::Deserializer<'de>,
16626    {
16627        const FIELDS: &[&str] = &[
16628            "init",
16629            "adds",
16630        ];
16631
16632        #[allow(clippy::enum_variant_names)]
16633        enum GeneratedField {
16634            Init,
16635            Adds,
16636        }
16637        impl<'de> serde::Deserialize<'de> for GeneratedField {
16638            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16639            where
16640                D: serde::Deserializer<'de>,
16641            {
16642                struct GeneratedVisitor;
16643
16644                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16645                    type Value = GeneratedField;
16646
16647                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16648                        write!(formatter, "expected one of: {:?}", &FIELDS)
16649                    }
16650
16651                    #[allow(unused_variables)]
16652                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16653                    where
16654                        E: serde::de::Error,
16655                    {
16656                        match value {
16657                            "init" => Ok(GeneratedField::Init),
16658                            "adds" => Ok(GeneratedField::Adds),
16659                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16660                        }
16661                    }
16662                }
16663                deserializer.deserialize_identifier(GeneratedVisitor)
16664            }
16665        }
16666        struct GeneratedVisitor;
16667        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16668            type Value = VectorIndexDelta;
16669
16670            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16671                formatter.write_str("struct hummock.VectorIndexDelta")
16672            }
16673
16674            fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexDelta, V::Error>
16675                where
16676                    V: serde::de::MapAccess<'de>,
16677            {
16678                let mut delta__ = None;
16679                while let Some(k) = map_.next_key()? {
16680                    match k {
16681                        GeneratedField::Init => {
16682                            if delta__.is_some() {
16683                                return Err(serde::de::Error::duplicate_field("init"));
16684                            }
16685                            delta__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_delta::Delta::Init)
16686;
16687                        }
16688                        GeneratedField::Adds => {
16689                            if delta__.is_some() {
16690                                return Err(serde::de::Error::duplicate_field("adds"));
16691                            }
16692                            delta__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_delta::Delta::Adds)
16693;
16694                        }
16695                    }
16696                }
16697                Ok(VectorIndexDelta {
16698                    delta: delta__,
16699                })
16700            }
16701        }
16702        deserializer.deserialize_struct("hummock.VectorIndexDelta", FIELDS, GeneratedVisitor)
16703    }
16704}
16705impl serde::Serialize for vector_index_delta::VectorIndexAdd {
16706    #[allow(deprecated)]
16707    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16708    where
16709        S: serde::Serializer,
16710    {
16711        use serde::ser::SerializeStruct;
16712        let mut len = 0;
16713        if self.add.is_some() {
16714            len += 1;
16715        }
16716        let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta.VectorIndexAdd", len)?;
16717        if let Some(v) = self.add.as_ref() {
16718            match v {
16719                vector_index_delta::vector_index_add::Add::Flat(v) => {
16720                    struct_ser.serialize_field("flat", v)?;
16721                }
16722            }
16723        }
16724        struct_ser.end()
16725    }
16726}
16727impl<'de> serde::Deserialize<'de> for vector_index_delta::VectorIndexAdd {
16728    #[allow(deprecated)]
16729    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16730    where
16731        D: serde::Deserializer<'de>,
16732    {
16733        const FIELDS: &[&str] = &[
16734            "flat",
16735        ];
16736
16737        #[allow(clippy::enum_variant_names)]
16738        enum GeneratedField {
16739            Flat,
16740        }
16741        impl<'de> serde::Deserialize<'de> for GeneratedField {
16742            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16743            where
16744                D: serde::Deserializer<'de>,
16745            {
16746                struct GeneratedVisitor;
16747
16748                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16749                    type Value = GeneratedField;
16750
16751                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16752                        write!(formatter, "expected one of: {:?}", &FIELDS)
16753                    }
16754
16755                    #[allow(unused_variables)]
16756                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16757                    where
16758                        E: serde::de::Error,
16759                    {
16760                        match value {
16761                            "flat" => Ok(GeneratedField::Flat),
16762                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16763                        }
16764                    }
16765                }
16766                deserializer.deserialize_identifier(GeneratedVisitor)
16767            }
16768        }
16769        struct GeneratedVisitor;
16770        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16771            type Value = vector_index_delta::VectorIndexAdd;
16772
16773            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16774                formatter.write_str("struct hummock.VectorIndexDelta.VectorIndexAdd")
16775            }
16776
16777            fn visit_map<V>(self, mut map_: V) -> std::result::Result<vector_index_delta::VectorIndexAdd, V::Error>
16778                where
16779                    V: serde::de::MapAccess<'de>,
16780            {
16781                let mut add__ = None;
16782                while let Some(k) = map_.next_key()? {
16783                    match k {
16784                        GeneratedField::Flat => {
16785                            if add__.is_some() {
16786                                return Err(serde::de::Error::duplicate_field("flat"));
16787                            }
16788                            add__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_delta::vector_index_add::Add::Flat)
16789;
16790                        }
16791                    }
16792                }
16793                Ok(vector_index_delta::VectorIndexAdd {
16794                    add: add__,
16795                })
16796            }
16797        }
16798        deserializer.deserialize_struct("hummock.VectorIndexDelta.VectorIndexAdd", FIELDS, GeneratedVisitor)
16799    }
16800}
16801impl serde::Serialize for vector_index_delta::VectorIndexAdds {
16802    #[allow(deprecated)]
16803    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16804    where
16805        S: serde::Serializer,
16806    {
16807        use serde::ser::SerializeStruct;
16808        let mut len = 0;
16809        if !self.adds.is_empty() {
16810            len += 1;
16811        }
16812        let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta.VectorIndexAdds", len)?;
16813        if !self.adds.is_empty() {
16814            struct_ser.serialize_field("adds", &self.adds)?;
16815        }
16816        struct_ser.end()
16817    }
16818}
16819impl<'de> serde::Deserialize<'de> for vector_index_delta::VectorIndexAdds {
16820    #[allow(deprecated)]
16821    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16822    where
16823        D: serde::Deserializer<'de>,
16824    {
16825        const FIELDS: &[&str] = &[
16826            "adds",
16827        ];
16828
16829        #[allow(clippy::enum_variant_names)]
16830        enum GeneratedField {
16831            Adds,
16832        }
16833        impl<'de> serde::Deserialize<'de> for GeneratedField {
16834            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16835            where
16836                D: serde::Deserializer<'de>,
16837            {
16838                struct GeneratedVisitor;
16839
16840                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16841                    type Value = GeneratedField;
16842
16843                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16844                        write!(formatter, "expected one of: {:?}", &FIELDS)
16845                    }
16846
16847                    #[allow(unused_variables)]
16848                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16849                    where
16850                        E: serde::de::Error,
16851                    {
16852                        match value {
16853                            "adds" => Ok(GeneratedField::Adds),
16854                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16855                        }
16856                    }
16857                }
16858                deserializer.deserialize_identifier(GeneratedVisitor)
16859            }
16860        }
16861        struct GeneratedVisitor;
16862        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16863            type Value = vector_index_delta::VectorIndexAdds;
16864
16865            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16866                formatter.write_str("struct hummock.VectorIndexDelta.VectorIndexAdds")
16867            }
16868
16869            fn visit_map<V>(self, mut map_: V) -> std::result::Result<vector_index_delta::VectorIndexAdds, V::Error>
16870                where
16871                    V: serde::de::MapAccess<'de>,
16872            {
16873                let mut adds__ = None;
16874                while let Some(k) = map_.next_key()? {
16875                    match k {
16876                        GeneratedField::Adds => {
16877                            if adds__.is_some() {
16878                                return Err(serde::de::Error::duplicate_field("adds"));
16879                            }
16880                            adds__ = Some(map_.next_value()?);
16881                        }
16882                    }
16883                }
16884                Ok(vector_index_delta::VectorIndexAdds {
16885                    adds: adds__.unwrap_or_default(),
16886                })
16887            }
16888        }
16889        deserializer.deserialize_struct("hummock.VectorIndexDelta.VectorIndexAdds", FIELDS, GeneratedVisitor)
16890    }
16891}
16892impl serde::Serialize for vector_index_delta::VectorIndexInit {
16893    #[allow(deprecated)]
16894    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16895    where
16896        S: serde::Serializer,
16897    {
16898        use serde::ser::SerializeStruct;
16899        let mut len = 0;
16900        if self.dimension != 0 {
16901            len += 1;
16902        }
16903        if self.distance_type != 0 {
16904            len += 1;
16905        }
16906        if self.config.is_some() {
16907            len += 1;
16908        }
16909        let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexDelta.VectorIndexInit", len)?;
16910        if self.dimension != 0 {
16911            struct_ser.serialize_field("dimension", &self.dimension)?;
16912        }
16913        if self.distance_type != 0 {
16914            let v = DistanceType::try_from(self.distance_type)
16915                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distance_type)))?;
16916            struct_ser.serialize_field("distanceType", &v)?;
16917        }
16918        if let Some(v) = self.config.as_ref() {
16919            match v {
16920                vector_index_delta::vector_index_init::Config::Flat(v) => {
16921                    struct_ser.serialize_field("flat", v)?;
16922                }
16923            }
16924        }
16925        struct_ser.end()
16926    }
16927}
16928impl<'de> serde::Deserialize<'de> for vector_index_delta::VectorIndexInit {
16929    #[allow(deprecated)]
16930    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16931    where
16932        D: serde::Deserializer<'de>,
16933    {
16934        const FIELDS: &[&str] = &[
16935            "dimension",
16936            "distance_type",
16937            "distanceType",
16938            "flat",
16939        ];
16940
16941        #[allow(clippy::enum_variant_names)]
16942        enum GeneratedField {
16943            Dimension,
16944            DistanceType,
16945            Flat,
16946        }
16947        impl<'de> serde::Deserialize<'de> for GeneratedField {
16948            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16949            where
16950                D: serde::Deserializer<'de>,
16951            {
16952                struct GeneratedVisitor;
16953
16954                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16955                    type Value = GeneratedField;
16956
16957                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16958                        write!(formatter, "expected one of: {:?}", &FIELDS)
16959                    }
16960
16961                    #[allow(unused_variables)]
16962                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16963                    where
16964                        E: serde::de::Error,
16965                    {
16966                        match value {
16967                            "dimension" => Ok(GeneratedField::Dimension),
16968                            "distanceType" | "distance_type" => Ok(GeneratedField::DistanceType),
16969                            "flat" => Ok(GeneratedField::Flat),
16970                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16971                        }
16972                    }
16973                }
16974                deserializer.deserialize_identifier(GeneratedVisitor)
16975            }
16976        }
16977        struct GeneratedVisitor;
16978        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16979            type Value = vector_index_delta::VectorIndexInit;
16980
16981            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16982                formatter.write_str("struct hummock.VectorIndexDelta.VectorIndexInit")
16983            }
16984
16985            fn visit_map<V>(self, mut map_: V) -> std::result::Result<vector_index_delta::VectorIndexInit, V::Error>
16986                where
16987                    V: serde::de::MapAccess<'de>,
16988            {
16989                let mut dimension__ = None;
16990                let mut distance_type__ = None;
16991                let mut config__ = None;
16992                while let Some(k) = map_.next_key()? {
16993                    match k {
16994                        GeneratedField::Dimension => {
16995                            if dimension__.is_some() {
16996                                return Err(serde::de::Error::duplicate_field("dimension"));
16997                            }
16998                            dimension__ = 
16999                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17000                            ;
17001                        }
17002                        GeneratedField::DistanceType => {
17003                            if distance_type__.is_some() {
17004                                return Err(serde::de::Error::duplicate_field("distanceType"));
17005                            }
17006                            distance_type__ = Some(map_.next_value::<DistanceType>()? as i32);
17007                        }
17008                        GeneratedField::Flat => {
17009                            if config__.is_some() {
17010                                return Err(serde::de::Error::duplicate_field("flat"));
17011                            }
17012                            config__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_delta::vector_index_init::Config::Flat)
17013;
17014                        }
17015                    }
17016                }
17017                Ok(vector_index_delta::VectorIndexInit {
17018                    dimension: dimension__.unwrap_or_default(),
17019                    distance_type: distance_type__.unwrap_or_default(),
17020                    config: config__,
17021                })
17022            }
17023        }
17024        deserializer.deserialize_struct("hummock.VectorIndexDelta.VectorIndexInit", FIELDS, GeneratedVisitor)
17025    }
17026}
17027impl serde::Serialize for VectorIndexObject {
17028    #[allow(deprecated)]
17029    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17030    where
17031        S: serde::Serializer,
17032    {
17033        use serde::ser::SerializeStruct;
17034        let mut len = 0;
17035        if self.id != 0 {
17036            len += 1;
17037        }
17038        if self.object_type != 0 {
17039            len += 1;
17040        }
17041        let mut struct_ser = serializer.serialize_struct("hummock.VectorIndexObject", len)?;
17042        if self.id != 0 {
17043            #[allow(clippy::needless_borrow)]
17044            #[allow(clippy::needless_borrows_for_generic_args)]
17045            struct_ser.serialize_field("id", ToString::to_string(&self.id).as_str())?;
17046        }
17047        if self.object_type != 0 {
17048            let v = VectorIndexObjectType::try_from(self.object_type)
17049                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.object_type)))?;
17050            struct_ser.serialize_field("objectType", &v)?;
17051        }
17052        struct_ser.end()
17053    }
17054}
17055impl<'de> serde::Deserialize<'de> for VectorIndexObject {
17056    #[allow(deprecated)]
17057    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17058    where
17059        D: serde::Deserializer<'de>,
17060    {
17061        const FIELDS: &[&str] = &[
17062            "id",
17063            "object_type",
17064            "objectType",
17065        ];
17066
17067        #[allow(clippy::enum_variant_names)]
17068        enum GeneratedField {
17069            Id,
17070            ObjectType,
17071        }
17072        impl<'de> serde::Deserialize<'de> for GeneratedField {
17073            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17074            where
17075                D: serde::Deserializer<'de>,
17076            {
17077                struct GeneratedVisitor;
17078
17079                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17080                    type Value = GeneratedField;
17081
17082                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17083                        write!(formatter, "expected one of: {:?}", &FIELDS)
17084                    }
17085
17086                    #[allow(unused_variables)]
17087                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17088                    where
17089                        E: serde::de::Error,
17090                    {
17091                        match value {
17092                            "id" => Ok(GeneratedField::Id),
17093                            "objectType" | "object_type" => Ok(GeneratedField::ObjectType),
17094                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17095                        }
17096                    }
17097                }
17098                deserializer.deserialize_identifier(GeneratedVisitor)
17099            }
17100        }
17101        struct GeneratedVisitor;
17102        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17103            type Value = VectorIndexObject;
17104
17105            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17106                formatter.write_str("struct hummock.VectorIndexObject")
17107            }
17108
17109            fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexObject, V::Error>
17110                where
17111                    V: serde::de::MapAccess<'de>,
17112            {
17113                let mut id__ = None;
17114                let mut object_type__ = None;
17115                while let Some(k) = map_.next_key()? {
17116                    match k {
17117                        GeneratedField::Id => {
17118                            if id__.is_some() {
17119                                return Err(serde::de::Error::duplicate_field("id"));
17120                            }
17121                            id__ = 
17122                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17123                            ;
17124                        }
17125                        GeneratedField::ObjectType => {
17126                            if object_type__.is_some() {
17127                                return Err(serde::de::Error::duplicate_field("objectType"));
17128                            }
17129                            object_type__ = Some(map_.next_value::<VectorIndexObjectType>()? as i32);
17130                        }
17131                    }
17132                }
17133                Ok(VectorIndexObject {
17134                    id: id__.unwrap_or_default(),
17135                    object_type: object_type__.unwrap_or_default(),
17136                })
17137            }
17138        }
17139        deserializer.deserialize_struct("hummock.VectorIndexObject", FIELDS, GeneratedVisitor)
17140    }
17141}
17142impl serde::Serialize for VectorIndexObjectType {
17143    #[allow(deprecated)]
17144    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17145    where
17146        S: serde::Serializer,
17147    {
17148        let variant = match self {
17149            Self::VectorIndexObjectUnspecified => "VECTOR_INDEX_OBJECT_UNSPECIFIED",
17150            Self::VectorIndexObjectVector => "VECTOR_INDEX_OBJECT_VECTOR",
17151        };
17152        serializer.serialize_str(variant)
17153    }
17154}
17155impl<'de> serde::Deserialize<'de> for VectorIndexObjectType {
17156    #[allow(deprecated)]
17157    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17158    where
17159        D: serde::Deserializer<'de>,
17160    {
17161        const FIELDS: &[&str] = &[
17162            "VECTOR_INDEX_OBJECT_UNSPECIFIED",
17163            "VECTOR_INDEX_OBJECT_VECTOR",
17164        ];
17165
17166        struct GeneratedVisitor;
17167
17168        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17169            type Value = VectorIndexObjectType;
17170
17171            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17172                write!(formatter, "expected one of: {:?}", &FIELDS)
17173            }
17174
17175            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
17176            where
17177                E: serde::de::Error,
17178            {
17179                i32::try_from(v)
17180                    .ok()
17181                    .and_then(|x| x.try_into().ok())
17182                    .ok_or_else(|| {
17183                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
17184                    })
17185            }
17186
17187            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
17188            where
17189                E: serde::de::Error,
17190            {
17191                i32::try_from(v)
17192                    .ok()
17193                    .and_then(|x| x.try_into().ok())
17194                    .ok_or_else(|| {
17195                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
17196                    })
17197            }
17198
17199            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
17200            where
17201                E: serde::de::Error,
17202            {
17203                match value {
17204                    "VECTOR_INDEX_OBJECT_UNSPECIFIED" => Ok(VectorIndexObjectType::VectorIndexObjectUnspecified),
17205                    "VECTOR_INDEX_OBJECT_VECTOR" => Ok(VectorIndexObjectType::VectorIndexObjectVector),
17206                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
17207                }
17208            }
17209        }
17210        deserializer.deserialize_any(GeneratedVisitor)
17211    }
17212}
17213impl serde::Serialize for VersionUpdatePayload {
17214    #[allow(deprecated)]
17215    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17216    where
17217        S: serde::Serializer,
17218    {
17219        use serde::ser::SerializeStruct;
17220        let mut len = 0;
17221        if self.payload.is_some() {
17222            len += 1;
17223        }
17224        let mut struct_ser = serializer.serialize_struct("hummock.VersionUpdatePayload", len)?;
17225        if let Some(v) = self.payload.as_ref() {
17226            match v {
17227                version_update_payload::Payload::VersionDeltas(v) => {
17228                    struct_ser.serialize_field("versionDeltas", v)?;
17229                }
17230                version_update_payload::Payload::PinnedVersion(v) => {
17231                    struct_ser.serialize_field("pinnedVersion", v)?;
17232                }
17233            }
17234        }
17235        struct_ser.end()
17236    }
17237}
17238impl<'de> serde::Deserialize<'de> for VersionUpdatePayload {
17239    #[allow(deprecated)]
17240    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17241    where
17242        D: serde::Deserializer<'de>,
17243    {
17244        const FIELDS: &[&str] = &[
17245            "version_deltas",
17246            "versionDeltas",
17247            "pinned_version",
17248            "pinnedVersion",
17249        ];
17250
17251        #[allow(clippy::enum_variant_names)]
17252        enum GeneratedField {
17253            VersionDeltas,
17254            PinnedVersion,
17255        }
17256        impl<'de> serde::Deserialize<'de> for GeneratedField {
17257            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17258            where
17259                D: serde::Deserializer<'de>,
17260            {
17261                struct GeneratedVisitor;
17262
17263                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17264                    type Value = GeneratedField;
17265
17266                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17267                        write!(formatter, "expected one of: {:?}", &FIELDS)
17268                    }
17269
17270                    #[allow(unused_variables)]
17271                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17272                    where
17273                        E: serde::de::Error,
17274                    {
17275                        match value {
17276                            "versionDeltas" | "version_deltas" => Ok(GeneratedField::VersionDeltas),
17277                            "pinnedVersion" | "pinned_version" => Ok(GeneratedField::PinnedVersion),
17278                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17279                        }
17280                    }
17281                }
17282                deserializer.deserialize_identifier(GeneratedVisitor)
17283            }
17284        }
17285        struct GeneratedVisitor;
17286        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17287            type Value = VersionUpdatePayload;
17288
17289            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17290                formatter.write_str("struct hummock.VersionUpdatePayload")
17291            }
17292
17293            fn visit_map<V>(self, mut map_: V) -> std::result::Result<VersionUpdatePayload, V::Error>
17294                where
17295                    V: serde::de::MapAccess<'de>,
17296            {
17297                let mut payload__ = None;
17298                while let Some(k) = map_.next_key()? {
17299                    match k {
17300                        GeneratedField::VersionDeltas => {
17301                            if payload__.is_some() {
17302                                return Err(serde::de::Error::duplicate_field("versionDeltas"));
17303                            }
17304                            payload__ = map_.next_value::<::std::option::Option<_>>()?.map(version_update_payload::Payload::VersionDeltas)
17305;
17306                        }
17307                        GeneratedField::PinnedVersion => {
17308                            if payload__.is_some() {
17309                                return Err(serde::de::Error::duplicate_field("pinnedVersion"));
17310                            }
17311                            payload__ = map_.next_value::<::std::option::Option<_>>()?.map(version_update_payload::Payload::PinnedVersion)
17312;
17313                        }
17314                    }
17315                }
17316                Ok(VersionUpdatePayload {
17317                    payload: payload__,
17318                })
17319            }
17320        }
17321        deserializer.deserialize_struct("hummock.VersionUpdatePayload", FIELDS, GeneratedVisitor)
17322    }
17323}
17324impl serde::Serialize for VnodeWatermark {
17325    #[allow(deprecated)]
17326    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17327    where
17328        S: serde::Serializer,
17329    {
17330        use serde::ser::SerializeStruct;
17331        let mut len = 0;
17332        if !self.watermark.is_empty() {
17333            len += 1;
17334        }
17335        if self.vnode_bitmap.is_some() {
17336            len += 1;
17337        }
17338        let mut struct_ser = serializer.serialize_struct("hummock.VnodeWatermark", len)?;
17339        if !self.watermark.is_empty() {
17340            #[allow(clippy::needless_borrow)]
17341            #[allow(clippy::needless_borrows_for_generic_args)]
17342            struct_ser.serialize_field("watermark", pbjson::private::base64::encode(&self.watermark).as_str())?;
17343        }
17344        if let Some(v) = self.vnode_bitmap.as_ref() {
17345            struct_ser.serialize_field("vnodeBitmap", v)?;
17346        }
17347        struct_ser.end()
17348    }
17349}
17350impl<'de> serde::Deserialize<'de> for VnodeWatermark {
17351    #[allow(deprecated)]
17352    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17353    where
17354        D: serde::Deserializer<'de>,
17355    {
17356        const FIELDS: &[&str] = &[
17357            "watermark",
17358            "vnode_bitmap",
17359            "vnodeBitmap",
17360        ];
17361
17362        #[allow(clippy::enum_variant_names)]
17363        enum GeneratedField {
17364            Watermark,
17365            VnodeBitmap,
17366        }
17367        impl<'de> serde::Deserialize<'de> for GeneratedField {
17368            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17369            where
17370                D: serde::Deserializer<'de>,
17371            {
17372                struct GeneratedVisitor;
17373
17374                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17375                    type Value = GeneratedField;
17376
17377                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17378                        write!(formatter, "expected one of: {:?}", &FIELDS)
17379                    }
17380
17381                    #[allow(unused_variables)]
17382                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17383                    where
17384                        E: serde::de::Error,
17385                    {
17386                        match value {
17387                            "watermark" => Ok(GeneratedField::Watermark),
17388                            "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
17389                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17390                        }
17391                    }
17392                }
17393                deserializer.deserialize_identifier(GeneratedVisitor)
17394            }
17395        }
17396        struct GeneratedVisitor;
17397        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17398            type Value = VnodeWatermark;
17399
17400            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17401                formatter.write_str("struct hummock.VnodeWatermark")
17402            }
17403
17404            fn visit_map<V>(self, mut map_: V) -> std::result::Result<VnodeWatermark, V::Error>
17405                where
17406                    V: serde::de::MapAccess<'de>,
17407            {
17408                let mut watermark__ = None;
17409                let mut vnode_bitmap__ = None;
17410                while let Some(k) = map_.next_key()? {
17411                    match k {
17412                        GeneratedField::Watermark => {
17413                            if watermark__.is_some() {
17414                                return Err(serde::de::Error::duplicate_field("watermark"));
17415                            }
17416                            watermark__ = 
17417                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
17418                            ;
17419                        }
17420                        GeneratedField::VnodeBitmap => {
17421                            if vnode_bitmap__.is_some() {
17422                                return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
17423                            }
17424                            vnode_bitmap__ = map_.next_value()?;
17425                        }
17426                    }
17427                }
17428                Ok(VnodeWatermark {
17429                    watermark: watermark__.unwrap_or_default(),
17430                    vnode_bitmap: vnode_bitmap__,
17431                })
17432            }
17433        }
17434        deserializer.deserialize_struct("hummock.VnodeWatermark", FIELDS, GeneratedVisitor)
17435    }
17436}
17437impl serde::Serialize for WriteLimits {
17438    #[allow(deprecated)]
17439    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17440    where
17441        S: serde::Serializer,
17442    {
17443        use serde::ser::SerializeStruct;
17444        let mut len = 0;
17445        if !self.write_limits.is_empty() {
17446            len += 1;
17447        }
17448        let mut struct_ser = serializer.serialize_struct("hummock.WriteLimits", len)?;
17449        if !self.write_limits.is_empty() {
17450            struct_ser.serialize_field("writeLimits", &self.write_limits)?;
17451        }
17452        struct_ser.end()
17453    }
17454}
17455impl<'de> serde::Deserialize<'de> for WriteLimits {
17456    #[allow(deprecated)]
17457    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17458    where
17459        D: serde::Deserializer<'de>,
17460    {
17461        const FIELDS: &[&str] = &[
17462            "write_limits",
17463            "writeLimits",
17464        ];
17465
17466        #[allow(clippy::enum_variant_names)]
17467        enum GeneratedField {
17468            WriteLimits,
17469        }
17470        impl<'de> serde::Deserialize<'de> for GeneratedField {
17471            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17472            where
17473                D: serde::Deserializer<'de>,
17474            {
17475                struct GeneratedVisitor;
17476
17477                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17478                    type Value = GeneratedField;
17479
17480                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17481                        write!(formatter, "expected one of: {:?}", &FIELDS)
17482                    }
17483
17484                    #[allow(unused_variables)]
17485                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17486                    where
17487                        E: serde::de::Error,
17488                    {
17489                        match value {
17490                            "writeLimits" | "write_limits" => Ok(GeneratedField::WriteLimits),
17491                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17492                        }
17493                    }
17494                }
17495                deserializer.deserialize_identifier(GeneratedVisitor)
17496            }
17497        }
17498        struct GeneratedVisitor;
17499        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17500            type Value = WriteLimits;
17501
17502            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17503                formatter.write_str("struct hummock.WriteLimits")
17504            }
17505
17506            fn visit_map<V>(self, mut map_: V) -> std::result::Result<WriteLimits, V::Error>
17507                where
17508                    V: serde::de::MapAccess<'de>,
17509            {
17510                let mut write_limits__ = None;
17511                while let Some(k) = map_.next_key()? {
17512                    match k {
17513                        GeneratedField::WriteLimits => {
17514                            if write_limits__.is_some() {
17515                                return Err(serde::de::Error::duplicate_field("writeLimits"));
17516                            }
17517                            write_limits__ = Some(
17518                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
17519                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
17520                            );
17521                        }
17522                    }
17523                }
17524                Ok(WriteLimits {
17525                    write_limits: write_limits__.unwrap_or_default(),
17526                })
17527            }
17528        }
17529        deserializer.deserialize_struct("hummock.WriteLimits", FIELDS, GeneratedVisitor)
17530    }
17531}
17532impl serde::Serialize for write_limits::WriteLimit {
17533    #[allow(deprecated)]
17534    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17535    where
17536        S: serde::Serializer,
17537    {
17538        use serde::ser::SerializeStruct;
17539        let mut len = 0;
17540        if !self.table_ids.is_empty() {
17541            len += 1;
17542        }
17543        if !self.reason.is_empty() {
17544            len += 1;
17545        }
17546        let mut struct_ser = serializer.serialize_struct("hummock.WriteLimits.WriteLimit", len)?;
17547        if !self.table_ids.is_empty() {
17548            struct_ser.serialize_field("tableIds", &self.table_ids)?;
17549        }
17550        if !self.reason.is_empty() {
17551            struct_ser.serialize_field("reason", &self.reason)?;
17552        }
17553        struct_ser.end()
17554    }
17555}
17556impl<'de> serde::Deserialize<'de> for write_limits::WriteLimit {
17557    #[allow(deprecated)]
17558    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17559    where
17560        D: serde::Deserializer<'de>,
17561    {
17562        const FIELDS: &[&str] = &[
17563            "table_ids",
17564            "tableIds",
17565            "reason",
17566        ];
17567
17568        #[allow(clippy::enum_variant_names)]
17569        enum GeneratedField {
17570            TableIds,
17571            Reason,
17572        }
17573        impl<'de> serde::Deserialize<'de> for GeneratedField {
17574            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17575            where
17576                D: serde::Deserializer<'de>,
17577            {
17578                struct GeneratedVisitor;
17579
17580                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17581                    type Value = GeneratedField;
17582
17583                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17584                        write!(formatter, "expected one of: {:?}", &FIELDS)
17585                    }
17586
17587                    #[allow(unused_variables)]
17588                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17589                    where
17590                        E: serde::de::Error,
17591                    {
17592                        match value {
17593                            "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
17594                            "reason" => Ok(GeneratedField::Reason),
17595                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17596                        }
17597                    }
17598                }
17599                deserializer.deserialize_identifier(GeneratedVisitor)
17600            }
17601        }
17602        struct GeneratedVisitor;
17603        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17604            type Value = write_limits::WriteLimit;
17605
17606            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17607                formatter.write_str("struct hummock.WriteLimits.WriteLimit")
17608            }
17609
17610            fn visit_map<V>(self, mut map_: V) -> std::result::Result<write_limits::WriteLimit, V::Error>
17611                where
17612                    V: serde::de::MapAccess<'de>,
17613            {
17614                let mut table_ids__ = None;
17615                let mut reason__ = None;
17616                while let Some(k) = map_.next_key()? {
17617                    match k {
17618                        GeneratedField::TableIds => {
17619                            if table_ids__.is_some() {
17620                                return Err(serde::de::Error::duplicate_field("tableIds"));
17621                            }
17622                            table_ids__ = 
17623                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17624                                    .into_iter().map(|x| x.0).collect())
17625                            ;
17626                        }
17627                        GeneratedField::Reason => {
17628                            if reason__.is_some() {
17629                                return Err(serde::de::Error::duplicate_field("reason"));
17630                            }
17631                            reason__ = Some(map_.next_value()?);
17632                        }
17633                    }
17634                }
17635                Ok(write_limits::WriteLimit {
17636                    table_ids: table_ids__.unwrap_or_default(),
17637                    reason: reason__.unwrap_or_default(),
17638                })
17639            }
17640        }
17641        deserializer.deserialize_struct("hummock.WriteLimits.WriteLimit", FIELDS, GeneratedVisitor)
17642    }
17643}