Skip to main content

sui_rpc/proto/generated/
sui.rpc.v2.field_info.rs

1pub(crate) mod _field_impls {
2    #![allow(clippy::wrong_self_convention)]
3    use super::*;
4    use crate::field::MessageFields;
5    use crate::field::MessageField;
6    impl Argument {
7        pub const KIND_FIELD: &'static MessageField = &MessageField {
8            name: "kind",
9            json_name: "kind",
10            number: 1i32,
11            message_fields: None,
12        };
13        pub const INPUT_FIELD: &'static MessageField = &MessageField {
14            name: "input",
15            json_name: "input",
16            number: 2i32,
17            message_fields: None,
18        };
19        pub const RESULT_FIELD: &'static MessageField = &MessageField {
20            name: "result",
21            json_name: "result",
22            number: 3i32,
23            message_fields: None,
24        };
25        pub const SUBRESULT_FIELD: &'static MessageField = &MessageField {
26            name: "subresult",
27            json_name: "subresult",
28            number: 4i32,
29            message_fields: None,
30        };
31    }
32    impl MessageFields for Argument {
33        const FIELDS: &'static [&'static MessageField] = &[
34            Self::KIND_FIELD,
35            Self::INPUT_FIELD,
36            Self::RESULT_FIELD,
37            Self::SUBRESULT_FIELD,
38        ];
39    }
40    impl Argument {
41        pub fn path_builder() -> ArgumentFieldPathBuilder {
42            ArgumentFieldPathBuilder::new()
43        }
44    }
45    pub struct ArgumentFieldPathBuilder {
46        path: Vec<&'static str>,
47    }
48    impl ArgumentFieldPathBuilder {
49        #[allow(clippy::new_without_default)]
50        pub fn new() -> Self {
51            Self { path: Default::default() }
52        }
53        #[doc(hidden)]
54        pub fn new_with_base(base: Vec<&'static str>) -> Self {
55            Self { path: base }
56        }
57        pub fn finish(self) -> String {
58            self.path.join(".")
59        }
60        pub fn kind(mut self) -> String {
61            self.path.push(Argument::KIND_FIELD.name);
62            self.finish()
63        }
64        pub fn input(mut self) -> String {
65            self.path.push(Argument::INPUT_FIELD.name);
66            self.finish()
67        }
68        pub fn result(mut self) -> String {
69            self.path.push(Argument::RESULT_FIELD.name);
70            self.finish()
71        }
72        pub fn subresult(mut self) -> String {
73            self.path.push(Argument::SUBRESULT_FIELD.name);
74            self.finish()
75        }
76    }
77    impl BalanceChange {
78        pub const ADDRESS_FIELD: &'static MessageField = &MessageField {
79            name: "address",
80            json_name: "address",
81            number: 1i32,
82            message_fields: None,
83        };
84        pub const COIN_TYPE_FIELD: &'static MessageField = &MessageField {
85            name: "coin_type",
86            json_name: "coinType",
87            number: 2i32,
88            message_fields: None,
89        };
90        pub const AMOUNT_FIELD: &'static MessageField = &MessageField {
91            name: "amount",
92            json_name: "amount",
93            number: 3i32,
94            message_fields: None,
95        };
96    }
97    impl MessageFields for BalanceChange {
98        const FIELDS: &'static [&'static MessageField] = &[
99            Self::ADDRESS_FIELD,
100            Self::COIN_TYPE_FIELD,
101            Self::AMOUNT_FIELD,
102        ];
103    }
104    impl BalanceChange {
105        pub fn path_builder() -> BalanceChangeFieldPathBuilder {
106            BalanceChangeFieldPathBuilder::new()
107        }
108    }
109    pub struct BalanceChangeFieldPathBuilder {
110        path: Vec<&'static str>,
111    }
112    impl BalanceChangeFieldPathBuilder {
113        #[allow(clippy::new_without_default)]
114        pub fn new() -> Self {
115            Self { path: Default::default() }
116        }
117        #[doc(hidden)]
118        pub fn new_with_base(base: Vec<&'static str>) -> Self {
119            Self { path: base }
120        }
121        pub fn finish(self) -> String {
122            self.path.join(".")
123        }
124        pub fn address(mut self) -> String {
125            self.path.push(BalanceChange::ADDRESS_FIELD.name);
126            self.finish()
127        }
128        pub fn coin_type(mut self) -> String {
129            self.path.push(BalanceChange::COIN_TYPE_FIELD.name);
130            self.finish()
131        }
132        pub fn amount(mut self) -> String {
133            self.path.push(BalanceChange::AMOUNT_FIELD.name);
134            self.finish()
135        }
136    }
137    impl Bcs {
138        pub const NAME_FIELD: &'static MessageField = &MessageField {
139            name: "name",
140            json_name: "name",
141            number: 1i32,
142            message_fields: None,
143        };
144        pub const VALUE_FIELD: &'static MessageField = &MessageField {
145            name: "value",
146            json_name: "value",
147            number: 2i32,
148            message_fields: None,
149        };
150    }
151    impl MessageFields for Bcs {
152        const FIELDS: &'static [&'static MessageField] = &[
153            Self::NAME_FIELD,
154            Self::VALUE_FIELD,
155        ];
156    }
157    impl Bcs {
158        pub fn path_builder() -> BcsFieldPathBuilder {
159            BcsFieldPathBuilder::new()
160        }
161    }
162    pub struct BcsFieldPathBuilder {
163        path: Vec<&'static str>,
164    }
165    impl BcsFieldPathBuilder {
166        #[allow(clippy::new_without_default)]
167        pub fn new() -> Self {
168            Self { path: Default::default() }
169        }
170        #[doc(hidden)]
171        pub fn new_with_base(base: Vec<&'static str>) -> Self {
172            Self { path: base }
173        }
174        pub fn finish(self) -> String {
175            self.path.join(".")
176        }
177        pub fn name(mut self) -> String {
178            self.path.push(Bcs::NAME_FIELD.name);
179            self.finish()
180        }
181        pub fn value(mut self) -> String {
182            self.path.push(Bcs::VALUE_FIELD.name);
183            self.finish()
184        }
185    }
186    impl Checkpoint {
187        pub const SEQUENCE_NUMBER_FIELD: &'static MessageField = &MessageField {
188            name: "sequence_number",
189            json_name: "sequenceNumber",
190            number: 1i32,
191            message_fields: None,
192        };
193        pub const DIGEST_FIELD: &'static MessageField = &MessageField {
194            name: "digest",
195            json_name: "digest",
196            number: 2i32,
197            message_fields: None,
198        };
199        pub const SUMMARY_FIELD: &'static MessageField = &MessageField {
200            name: "summary",
201            json_name: "summary",
202            number: 3i32,
203            message_fields: Some(CheckpointSummary::FIELDS),
204        };
205        pub const SIGNATURE_FIELD: &'static MessageField = &MessageField {
206            name: "signature",
207            json_name: "signature",
208            number: 4i32,
209            message_fields: Some(ValidatorAggregatedSignature::FIELDS),
210        };
211        pub const CONTENTS_FIELD: &'static MessageField = &MessageField {
212            name: "contents",
213            json_name: "contents",
214            number: 5i32,
215            message_fields: Some(CheckpointContents::FIELDS),
216        };
217        pub const TRANSACTIONS_FIELD: &'static MessageField = &MessageField {
218            name: "transactions",
219            json_name: "transactions",
220            number: 6i32,
221            message_fields: Some(ExecutedTransaction::FIELDS),
222        };
223        pub const OBJECTS_FIELD: &'static MessageField = &MessageField {
224            name: "objects",
225            json_name: "objects",
226            number: 7i32,
227            message_fields: Some(ObjectSet::FIELDS),
228        };
229    }
230    impl MessageFields for Checkpoint {
231        const FIELDS: &'static [&'static MessageField] = &[
232            Self::SEQUENCE_NUMBER_FIELD,
233            Self::DIGEST_FIELD,
234            Self::SUMMARY_FIELD,
235            Self::SIGNATURE_FIELD,
236            Self::CONTENTS_FIELD,
237            Self::TRANSACTIONS_FIELD,
238            Self::OBJECTS_FIELD,
239        ];
240    }
241    impl Checkpoint {
242        pub fn path_builder() -> CheckpointFieldPathBuilder {
243            CheckpointFieldPathBuilder::new()
244        }
245    }
246    pub struct CheckpointFieldPathBuilder {
247        path: Vec<&'static str>,
248    }
249    impl CheckpointFieldPathBuilder {
250        #[allow(clippy::new_without_default)]
251        pub fn new() -> Self {
252            Self { path: Default::default() }
253        }
254        #[doc(hidden)]
255        pub fn new_with_base(base: Vec<&'static str>) -> Self {
256            Self { path: base }
257        }
258        pub fn finish(self) -> String {
259            self.path.join(".")
260        }
261        pub fn sequence_number(mut self) -> String {
262            self.path.push(Checkpoint::SEQUENCE_NUMBER_FIELD.name);
263            self.finish()
264        }
265        pub fn digest(mut self) -> String {
266            self.path.push(Checkpoint::DIGEST_FIELD.name);
267            self.finish()
268        }
269        pub fn summary(mut self) -> CheckpointSummaryFieldPathBuilder {
270            self.path.push(Checkpoint::SUMMARY_FIELD.name);
271            CheckpointSummaryFieldPathBuilder::new_with_base(self.path)
272        }
273        pub fn signature(mut self) -> ValidatorAggregatedSignatureFieldPathBuilder {
274            self.path.push(Checkpoint::SIGNATURE_FIELD.name);
275            ValidatorAggregatedSignatureFieldPathBuilder::new_with_base(self.path)
276        }
277        pub fn contents(mut self) -> CheckpointContentsFieldPathBuilder {
278            self.path.push(Checkpoint::CONTENTS_FIELD.name);
279            CheckpointContentsFieldPathBuilder::new_with_base(self.path)
280        }
281        pub fn transactions(mut self) -> ExecutedTransactionFieldPathBuilder {
282            self.path.push(Checkpoint::TRANSACTIONS_FIELD.name);
283            ExecutedTransactionFieldPathBuilder::new_with_base(self.path)
284        }
285        pub fn objects(mut self) -> ObjectSetFieldPathBuilder {
286            self.path.push(Checkpoint::OBJECTS_FIELD.name);
287            ObjectSetFieldPathBuilder::new_with_base(self.path)
288        }
289    }
290    impl CheckpointContents {
291        pub const BCS_FIELD: &'static MessageField = &MessageField {
292            name: "bcs",
293            json_name: "bcs",
294            number: 1i32,
295            message_fields: Some(Bcs::FIELDS),
296        };
297        pub const DIGEST_FIELD: &'static MessageField = &MessageField {
298            name: "digest",
299            json_name: "digest",
300            number: 2i32,
301            message_fields: None,
302        };
303        pub const VERSION_FIELD: &'static MessageField = &MessageField {
304            name: "version",
305            json_name: "version",
306            number: 3i32,
307            message_fields: None,
308        };
309        pub const TRANSACTIONS_FIELD: &'static MessageField = &MessageField {
310            name: "transactions",
311            json_name: "transactions",
312            number: 4i32,
313            message_fields: Some(CheckpointedTransactionInfo::FIELDS),
314        };
315    }
316    impl MessageFields for CheckpointContents {
317        const FIELDS: &'static [&'static MessageField] = &[
318            Self::BCS_FIELD,
319            Self::DIGEST_FIELD,
320            Self::VERSION_FIELD,
321            Self::TRANSACTIONS_FIELD,
322        ];
323    }
324    impl CheckpointContents {
325        pub fn path_builder() -> CheckpointContentsFieldPathBuilder {
326            CheckpointContentsFieldPathBuilder::new()
327        }
328    }
329    pub struct CheckpointContentsFieldPathBuilder {
330        path: Vec<&'static str>,
331    }
332    impl CheckpointContentsFieldPathBuilder {
333        #[allow(clippy::new_without_default)]
334        pub fn new() -> Self {
335            Self { path: Default::default() }
336        }
337        #[doc(hidden)]
338        pub fn new_with_base(base: Vec<&'static str>) -> Self {
339            Self { path: base }
340        }
341        pub fn finish(self) -> String {
342            self.path.join(".")
343        }
344        pub fn bcs(mut self) -> BcsFieldPathBuilder {
345            self.path.push(CheckpointContents::BCS_FIELD.name);
346            BcsFieldPathBuilder::new_with_base(self.path)
347        }
348        pub fn digest(mut self) -> String {
349            self.path.push(CheckpointContents::DIGEST_FIELD.name);
350            self.finish()
351        }
352        pub fn version(mut self) -> String {
353            self.path.push(CheckpointContents::VERSION_FIELD.name);
354            self.finish()
355        }
356        pub fn transactions(mut self) -> CheckpointedTransactionInfoFieldPathBuilder {
357            self.path.push(CheckpointContents::TRANSACTIONS_FIELD.name);
358            CheckpointedTransactionInfoFieldPathBuilder::new_with_base(self.path)
359        }
360    }
361    impl CheckpointedTransactionInfo {
362        pub const TRANSACTION_FIELD: &'static MessageField = &MessageField {
363            name: "transaction",
364            json_name: "transaction",
365            number: 1i32,
366            message_fields: None,
367        };
368        pub const EFFECTS_FIELD: &'static MessageField = &MessageField {
369            name: "effects",
370            json_name: "effects",
371            number: 2i32,
372            message_fields: None,
373        };
374        pub const SIGNATURES_FIELD: &'static MessageField = &MessageField {
375            name: "signatures",
376            json_name: "signatures",
377            number: 3i32,
378            message_fields: Some(UserSignature::FIELDS),
379        };
380        pub const ADDRESS_ALIASES_VERSIONS_FIELD: &'static MessageField = &MessageField {
381            name: "address_aliases_versions",
382            json_name: "addressAliasesVersions",
383            number: 4i32,
384            message_fields: Some(AddressAliasesVersion::FIELDS),
385        };
386    }
387    impl MessageFields for CheckpointedTransactionInfo {
388        const FIELDS: &'static [&'static MessageField] = &[
389            Self::TRANSACTION_FIELD,
390            Self::EFFECTS_FIELD,
391            Self::SIGNATURES_FIELD,
392            Self::ADDRESS_ALIASES_VERSIONS_FIELD,
393        ];
394    }
395    impl CheckpointedTransactionInfo {
396        pub fn path_builder() -> CheckpointedTransactionInfoFieldPathBuilder {
397            CheckpointedTransactionInfoFieldPathBuilder::new()
398        }
399    }
400    pub struct CheckpointedTransactionInfoFieldPathBuilder {
401        path: Vec<&'static str>,
402    }
403    impl CheckpointedTransactionInfoFieldPathBuilder {
404        #[allow(clippy::new_without_default)]
405        pub fn new() -> Self {
406            Self { path: Default::default() }
407        }
408        #[doc(hidden)]
409        pub fn new_with_base(base: Vec<&'static str>) -> Self {
410            Self { path: base }
411        }
412        pub fn finish(self) -> String {
413            self.path.join(".")
414        }
415        pub fn transaction(mut self) -> String {
416            self.path.push(CheckpointedTransactionInfo::TRANSACTION_FIELD.name);
417            self.finish()
418        }
419        pub fn effects(mut self) -> String {
420            self.path.push(CheckpointedTransactionInfo::EFFECTS_FIELD.name);
421            self.finish()
422        }
423        pub fn signatures(mut self) -> UserSignatureFieldPathBuilder {
424            self.path.push(CheckpointedTransactionInfo::SIGNATURES_FIELD.name);
425            UserSignatureFieldPathBuilder::new_with_base(self.path)
426        }
427        pub fn address_aliases_versions(
428            mut self,
429        ) -> AddressAliasesVersionFieldPathBuilder {
430            self.path
431                .push(CheckpointedTransactionInfo::ADDRESS_ALIASES_VERSIONS_FIELD.name);
432            AddressAliasesVersionFieldPathBuilder::new_with_base(self.path)
433        }
434    }
435    impl AddressAliasesVersion {
436        pub const VERSION_FIELD: &'static MessageField = &MessageField {
437            name: "version",
438            json_name: "version",
439            number: 1i32,
440            message_fields: None,
441        };
442    }
443    impl MessageFields for AddressAliasesVersion {
444        const FIELDS: &'static [&'static MessageField] = &[Self::VERSION_FIELD];
445    }
446    impl AddressAliasesVersion {
447        pub fn path_builder() -> AddressAliasesVersionFieldPathBuilder {
448            AddressAliasesVersionFieldPathBuilder::new()
449        }
450    }
451    pub struct AddressAliasesVersionFieldPathBuilder {
452        path: Vec<&'static str>,
453    }
454    impl AddressAliasesVersionFieldPathBuilder {
455        #[allow(clippy::new_without_default)]
456        pub fn new() -> Self {
457            Self { path: Default::default() }
458        }
459        #[doc(hidden)]
460        pub fn new_with_base(base: Vec<&'static str>) -> Self {
461            Self { path: base }
462        }
463        pub fn finish(self) -> String {
464            self.path.join(".")
465        }
466        pub fn version(mut self) -> String {
467            self.path.push(AddressAliasesVersion::VERSION_FIELD.name);
468            self.finish()
469        }
470    }
471    impl CheckpointSummary {
472        pub const BCS_FIELD: &'static MessageField = &MessageField {
473            name: "bcs",
474            json_name: "bcs",
475            number: 1i32,
476            message_fields: Some(Bcs::FIELDS),
477        };
478        pub const DIGEST_FIELD: &'static MessageField = &MessageField {
479            name: "digest",
480            json_name: "digest",
481            number: 2i32,
482            message_fields: None,
483        };
484        pub const EPOCH_FIELD: &'static MessageField = &MessageField {
485            name: "epoch",
486            json_name: "epoch",
487            number: 3i32,
488            message_fields: None,
489        };
490        pub const SEQUENCE_NUMBER_FIELD: &'static MessageField = &MessageField {
491            name: "sequence_number",
492            json_name: "sequenceNumber",
493            number: 4i32,
494            message_fields: None,
495        };
496        pub const TOTAL_NETWORK_TRANSACTIONS_FIELD: &'static MessageField = &MessageField {
497            name: "total_network_transactions",
498            json_name: "totalNetworkTransactions",
499            number: 5i32,
500            message_fields: None,
501        };
502        pub const CONTENT_DIGEST_FIELD: &'static MessageField = &MessageField {
503            name: "content_digest",
504            json_name: "contentDigest",
505            number: 6i32,
506            message_fields: None,
507        };
508        pub const PREVIOUS_DIGEST_FIELD: &'static MessageField = &MessageField {
509            name: "previous_digest",
510            json_name: "previousDigest",
511            number: 7i32,
512            message_fields: None,
513        };
514        pub const EPOCH_ROLLING_GAS_COST_SUMMARY_FIELD: &'static MessageField = &MessageField {
515            name: "epoch_rolling_gas_cost_summary",
516            json_name: "epochRollingGasCostSummary",
517            number: 8i32,
518            message_fields: Some(GasCostSummary::FIELDS),
519        };
520        pub const TIMESTAMP_FIELD: &'static MessageField = &MessageField {
521            name: "timestamp",
522            json_name: "timestamp",
523            number: 9i32,
524            message_fields: None,
525        };
526        pub const COMMITMENTS_FIELD: &'static MessageField = &MessageField {
527            name: "commitments",
528            json_name: "commitments",
529            number: 10i32,
530            message_fields: Some(CheckpointCommitment::FIELDS),
531        };
532        pub const END_OF_EPOCH_DATA_FIELD: &'static MessageField = &MessageField {
533            name: "end_of_epoch_data",
534            json_name: "endOfEpochData",
535            number: 11i32,
536            message_fields: Some(EndOfEpochData::FIELDS),
537        };
538        pub const VERSION_SPECIFIC_DATA_FIELD: &'static MessageField = &MessageField {
539            name: "version_specific_data",
540            json_name: "versionSpecificData",
541            number: 12i32,
542            message_fields: None,
543        };
544    }
545    impl MessageFields for CheckpointSummary {
546        const FIELDS: &'static [&'static MessageField] = &[
547            Self::BCS_FIELD,
548            Self::DIGEST_FIELD,
549            Self::EPOCH_FIELD,
550            Self::SEQUENCE_NUMBER_FIELD,
551            Self::TOTAL_NETWORK_TRANSACTIONS_FIELD,
552            Self::CONTENT_DIGEST_FIELD,
553            Self::PREVIOUS_DIGEST_FIELD,
554            Self::EPOCH_ROLLING_GAS_COST_SUMMARY_FIELD,
555            Self::TIMESTAMP_FIELD,
556            Self::COMMITMENTS_FIELD,
557            Self::END_OF_EPOCH_DATA_FIELD,
558            Self::VERSION_SPECIFIC_DATA_FIELD,
559        ];
560    }
561    impl CheckpointSummary {
562        pub fn path_builder() -> CheckpointSummaryFieldPathBuilder {
563            CheckpointSummaryFieldPathBuilder::new()
564        }
565    }
566    pub struct CheckpointSummaryFieldPathBuilder {
567        path: Vec<&'static str>,
568    }
569    impl CheckpointSummaryFieldPathBuilder {
570        #[allow(clippy::new_without_default)]
571        pub fn new() -> Self {
572            Self { path: Default::default() }
573        }
574        #[doc(hidden)]
575        pub fn new_with_base(base: Vec<&'static str>) -> Self {
576            Self { path: base }
577        }
578        pub fn finish(self) -> String {
579            self.path.join(".")
580        }
581        pub fn bcs(mut self) -> BcsFieldPathBuilder {
582            self.path.push(CheckpointSummary::BCS_FIELD.name);
583            BcsFieldPathBuilder::new_with_base(self.path)
584        }
585        pub fn digest(mut self) -> String {
586            self.path.push(CheckpointSummary::DIGEST_FIELD.name);
587            self.finish()
588        }
589        pub fn epoch(mut self) -> String {
590            self.path.push(CheckpointSummary::EPOCH_FIELD.name);
591            self.finish()
592        }
593        pub fn sequence_number(mut self) -> String {
594            self.path.push(CheckpointSummary::SEQUENCE_NUMBER_FIELD.name);
595            self.finish()
596        }
597        pub fn total_network_transactions(mut self) -> String {
598            self.path.push(CheckpointSummary::TOTAL_NETWORK_TRANSACTIONS_FIELD.name);
599            self.finish()
600        }
601        pub fn content_digest(mut self) -> String {
602            self.path.push(CheckpointSummary::CONTENT_DIGEST_FIELD.name);
603            self.finish()
604        }
605        pub fn previous_digest(mut self) -> String {
606            self.path.push(CheckpointSummary::PREVIOUS_DIGEST_FIELD.name);
607            self.finish()
608        }
609        pub fn epoch_rolling_gas_cost_summary(
610            mut self,
611        ) -> GasCostSummaryFieldPathBuilder {
612            self.path.push(CheckpointSummary::EPOCH_ROLLING_GAS_COST_SUMMARY_FIELD.name);
613            GasCostSummaryFieldPathBuilder::new_with_base(self.path)
614        }
615        pub fn timestamp(mut self) -> String {
616            self.path.push(CheckpointSummary::TIMESTAMP_FIELD.name);
617            self.finish()
618        }
619        pub fn commitments(mut self) -> CheckpointCommitmentFieldPathBuilder {
620            self.path.push(CheckpointSummary::COMMITMENTS_FIELD.name);
621            CheckpointCommitmentFieldPathBuilder::new_with_base(self.path)
622        }
623        pub fn end_of_epoch_data(mut self) -> EndOfEpochDataFieldPathBuilder {
624            self.path.push(CheckpointSummary::END_OF_EPOCH_DATA_FIELD.name);
625            EndOfEpochDataFieldPathBuilder::new_with_base(self.path)
626        }
627        pub fn version_specific_data(mut self) -> String {
628            self.path.push(CheckpointSummary::VERSION_SPECIFIC_DATA_FIELD.name);
629            self.finish()
630        }
631    }
632    impl EndOfEpochData {
633        pub const NEXT_EPOCH_COMMITTEE_FIELD: &'static MessageField = &MessageField {
634            name: "next_epoch_committee",
635            json_name: "nextEpochCommittee",
636            number: 1i32,
637            message_fields: Some(ValidatorCommitteeMember::FIELDS),
638        };
639        pub const NEXT_EPOCH_PROTOCOL_VERSION_FIELD: &'static MessageField = &MessageField {
640            name: "next_epoch_protocol_version",
641            json_name: "nextEpochProtocolVersion",
642            number: 2i32,
643            message_fields: None,
644        };
645        pub const EPOCH_COMMITMENTS_FIELD: &'static MessageField = &MessageField {
646            name: "epoch_commitments",
647            json_name: "epochCommitments",
648            number: 3i32,
649            message_fields: Some(CheckpointCommitment::FIELDS),
650        };
651    }
652    impl MessageFields for EndOfEpochData {
653        const FIELDS: &'static [&'static MessageField] = &[
654            Self::NEXT_EPOCH_COMMITTEE_FIELD,
655            Self::NEXT_EPOCH_PROTOCOL_VERSION_FIELD,
656            Self::EPOCH_COMMITMENTS_FIELD,
657        ];
658    }
659    impl EndOfEpochData {
660        pub fn path_builder() -> EndOfEpochDataFieldPathBuilder {
661            EndOfEpochDataFieldPathBuilder::new()
662        }
663    }
664    pub struct EndOfEpochDataFieldPathBuilder {
665        path: Vec<&'static str>,
666    }
667    impl EndOfEpochDataFieldPathBuilder {
668        #[allow(clippy::new_without_default)]
669        pub fn new() -> Self {
670            Self { path: Default::default() }
671        }
672        #[doc(hidden)]
673        pub fn new_with_base(base: Vec<&'static str>) -> Self {
674            Self { path: base }
675        }
676        pub fn finish(self) -> String {
677            self.path.join(".")
678        }
679        pub fn next_epoch_committee(
680            mut self,
681        ) -> ValidatorCommitteeMemberFieldPathBuilder {
682            self.path.push(EndOfEpochData::NEXT_EPOCH_COMMITTEE_FIELD.name);
683            ValidatorCommitteeMemberFieldPathBuilder::new_with_base(self.path)
684        }
685        pub fn next_epoch_protocol_version(mut self) -> String {
686            self.path.push(EndOfEpochData::NEXT_EPOCH_PROTOCOL_VERSION_FIELD.name);
687            self.finish()
688        }
689        pub fn epoch_commitments(mut self) -> CheckpointCommitmentFieldPathBuilder {
690            self.path.push(EndOfEpochData::EPOCH_COMMITMENTS_FIELD.name);
691            CheckpointCommitmentFieldPathBuilder::new_with_base(self.path)
692        }
693    }
694    impl CheckpointCommitment {
695        pub const KIND_FIELD: &'static MessageField = &MessageField {
696            name: "kind",
697            json_name: "kind",
698            number: 1i32,
699            message_fields: None,
700        };
701        pub const DIGEST_FIELD: &'static MessageField = &MessageField {
702            name: "digest",
703            json_name: "digest",
704            number: 2i32,
705            message_fields: None,
706        };
707    }
708    impl MessageFields for CheckpointCommitment {
709        const FIELDS: &'static [&'static MessageField] = &[
710            Self::KIND_FIELD,
711            Self::DIGEST_FIELD,
712        ];
713    }
714    impl CheckpointCommitment {
715        pub fn path_builder() -> CheckpointCommitmentFieldPathBuilder {
716            CheckpointCommitmentFieldPathBuilder::new()
717        }
718    }
719    pub struct CheckpointCommitmentFieldPathBuilder {
720        path: Vec<&'static str>,
721    }
722    impl CheckpointCommitmentFieldPathBuilder {
723        #[allow(clippy::new_without_default)]
724        pub fn new() -> Self {
725            Self { path: Default::default() }
726        }
727        #[doc(hidden)]
728        pub fn new_with_base(base: Vec<&'static str>) -> Self {
729            Self { path: base }
730        }
731        pub fn finish(self) -> String {
732            self.path.join(".")
733        }
734        pub fn kind(mut self) -> String {
735            self.path.push(CheckpointCommitment::KIND_FIELD.name);
736            self.finish()
737        }
738        pub fn digest(mut self) -> String {
739            self.path.push(CheckpointCommitment::DIGEST_FIELD.name);
740            self.finish()
741        }
742    }
743    impl TransactionEffects {
744        pub const BCS_FIELD: &'static MessageField = &MessageField {
745            name: "bcs",
746            json_name: "bcs",
747            number: 1i32,
748            message_fields: Some(Bcs::FIELDS),
749        };
750        pub const DIGEST_FIELD: &'static MessageField = &MessageField {
751            name: "digest",
752            json_name: "digest",
753            number: 2i32,
754            message_fields: None,
755        };
756        pub const VERSION_FIELD: &'static MessageField = &MessageField {
757            name: "version",
758            json_name: "version",
759            number: 3i32,
760            message_fields: None,
761        };
762        pub const STATUS_FIELD: &'static MessageField = &MessageField {
763            name: "status",
764            json_name: "status",
765            number: 4i32,
766            message_fields: Some(ExecutionStatus::FIELDS),
767        };
768        pub const EPOCH_FIELD: &'static MessageField = &MessageField {
769            name: "epoch",
770            json_name: "epoch",
771            number: 5i32,
772            message_fields: None,
773        };
774        pub const GAS_USED_FIELD: &'static MessageField = &MessageField {
775            name: "gas_used",
776            json_name: "gasUsed",
777            number: 6i32,
778            message_fields: Some(GasCostSummary::FIELDS),
779        };
780        pub const TRANSACTION_DIGEST_FIELD: &'static MessageField = &MessageField {
781            name: "transaction_digest",
782            json_name: "transactionDigest",
783            number: 7i32,
784            message_fields: None,
785        };
786        pub const GAS_OBJECT_FIELD: &'static MessageField = &MessageField {
787            name: "gas_object",
788            json_name: "gasObject",
789            number: 8i32,
790            message_fields: Some(ChangedObject::FIELDS),
791        };
792        pub const EVENTS_DIGEST_FIELD: &'static MessageField = &MessageField {
793            name: "events_digest",
794            json_name: "eventsDigest",
795            number: 9i32,
796            message_fields: None,
797        };
798        pub const DEPENDENCIES_FIELD: &'static MessageField = &MessageField {
799            name: "dependencies",
800            json_name: "dependencies",
801            number: 10i32,
802            message_fields: None,
803        };
804        pub const LAMPORT_VERSION_FIELD: &'static MessageField = &MessageField {
805            name: "lamport_version",
806            json_name: "lamportVersion",
807            number: 11i32,
808            message_fields: None,
809        };
810        pub const CHANGED_OBJECTS_FIELD: &'static MessageField = &MessageField {
811            name: "changed_objects",
812            json_name: "changedObjects",
813            number: 12i32,
814            message_fields: Some(ChangedObject::FIELDS),
815        };
816        pub const UNCHANGED_CONSENSUS_OBJECTS_FIELD: &'static MessageField = &MessageField {
817            name: "unchanged_consensus_objects",
818            json_name: "unchangedConsensusObjects",
819            number: 13i32,
820            message_fields: Some(UnchangedConsensusObject::FIELDS),
821        };
822        pub const AUXILIARY_DATA_DIGEST_FIELD: &'static MessageField = &MessageField {
823            name: "auxiliary_data_digest",
824            json_name: "auxiliaryDataDigest",
825            number: 14i32,
826            message_fields: None,
827        };
828        pub const UNCHANGED_LOADED_RUNTIME_OBJECTS_FIELD: &'static MessageField = &MessageField {
829            name: "unchanged_loaded_runtime_objects",
830            json_name: "unchangedLoadedRuntimeObjects",
831            number: 15i32,
832            message_fields: Some(ObjectReference::FIELDS),
833        };
834    }
835    impl MessageFields for TransactionEffects {
836        const FIELDS: &'static [&'static MessageField] = &[
837            Self::BCS_FIELD,
838            Self::DIGEST_FIELD,
839            Self::VERSION_FIELD,
840            Self::STATUS_FIELD,
841            Self::EPOCH_FIELD,
842            Self::GAS_USED_FIELD,
843            Self::TRANSACTION_DIGEST_FIELD,
844            Self::GAS_OBJECT_FIELD,
845            Self::EVENTS_DIGEST_FIELD,
846            Self::DEPENDENCIES_FIELD,
847            Self::LAMPORT_VERSION_FIELD,
848            Self::CHANGED_OBJECTS_FIELD,
849            Self::UNCHANGED_CONSENSUS_OBJECTS_FIELD,
850            Self::AUXILIARY_DATA_DIGEST_FIELD,
851            Self::UNCHANGED_LOADED_RUNTIME_OBJECTS_FIELD,
852        ];
853    }
854    impl TransactionEffects {
855        pub fn path_builder() -> TransactionEffectsFieldPathBuilder {
856            TransactionEffectsFieldPathBuilder::new()
857        }
858    }
859    pub struct TransactionEffectsFieldPathBuilder {
860        path: Vec<&'static str>,
861    }
862    impl TransactionEffectsFieldPathBuilder {
863        #[allow(clippy::new_without_default)]
864        pub fn new() -> Self {
865            Self { path: Default::default() }
866        }
867        #[doc(hidden)]
868        pub fn new_with_base(base: Vec<&'static str>) -> Self {
869            Self { path: base }
870        }
871        pub fn finish(self) -> String {
872            self.path.join(".")
873        }
874        pub fn bcs(mut self) -> BcsFieldPathBuilder {
875            self.path.push(TransactionEffects::BCS_FIELD.name);
876            BcsFieldPathBuilder::new_with_base(self.path)
877        }
878        pub fn digest(mut self) -> String {
879            self.path.push(TransactionEffects::DIGEST_FIELD.name);
880            self.finish()
881        }
882        pub fn version(mut self) -> String {
883            self.path.push(TransactionEffects::VERSION_FIELD.name);
884            self.finish()
885        }
886        pub fn status(mut self) -> ExecutionStatusFieldPathBuilder {
887            self.path.push(TransactionEffects::STATUS_FIELD.name);
888            ExecutionStatusFieldPathBuilder::new_with_base(self.path)
889        }
890        pub fn epoch(mut self) -> String {
891            self.path.push(TransactionEffects::EPOCH_FIELD.name);
892            self.finish()
893        }
894        pub fn gas_used(mut self) -> GasCostSummaryFieldPathBuilder {
895            self.path.push(TransactionEffects::GAS_USED_FIELD.name);
896            GasCostSummaryFieldPathBuilder::new_with_base(self.path)
897        }
898        pub fn transaction_digest(mut self) -> String {
899            self.path.push(TransactionEffects::TRANSACTION_DIGEST_FIELD.name);
900            self.finish()
901        }
902        pub fn gas_object(mut self) -> ChangedObjectFieldPathBuilder {
903            self.path.push(TransactionEffects::GAS_OBJECT_FIELD.name);
904            ChangedObjectFieldPathBuilder::new_with_base(self.path)
905        }
906        pub fn events_digest(mut self) -> String {
907            self.path.push(TransactionEffects::EVENTS_DIGEST_FIELD.name);
908            self.finish()
909        }
910        pub fn dependencies(mut self) -> String {
911            self.path.push(TransactionEffects::DEPENDENCIES_FIELD.name);
912            self.finish()
913        }
914        pub fn lamport_version(mut self) -> String {
915            self.path.push(TransactionEffects::LAMPORT_VERSION_FIELD.name);
916            self.finish()
917        }
918        pub fn changed_objects(mut self) -> ChangedObjectFieldPathBuilder {
919            self.path.push(TransactionEffects::CHANGED_OBJECTS_FIELD.name);
920            ChangedObjectFieldPathBuilder::new_with_base(self.path)
921        }
922        pub fn unchanged_consensus_objects(
923            mut self,
924        ) -> UnchangedConsensusObjectFieldPathBuilder {
925            self.path.push(TransactionEffects::UNCHANGED_CONSENSUS_OBJECTS_FIELD.name);
926            UnchangedConsensusObjectFieldPathBuilder::new_with_base(self.path)
927        }
928        pub fn auxiliary_data_digest(mut self) -> String {
929            self.path.push(TransactionEffects::AUXILIARY_DATA_DIGEST_FIELD.name);
930            self.finish()
931        }
932        pub fn unchanged_loaded_runtime_objects(
933            mut self,
934        ) -> ObjectReferenceFieldPathBuilder {
935            self.path
936                .push(TransactionEffects::UNCHANGED_LOADED_RUNTIME_OBJECTS_FIELD.name);
937            ObjectReferenceFieldPathBuilder::new_with_base(self.path)
938        }
939    }
940    impl ChangedObject {
941        pub const OBJECT_ID_FIELD: &'static MessageField = &MessageField {
942            name: "object_id",
943            json_name: "objectId",
944            number: 1i32,
945            message_fields: None,
946        };
947        pub const INPUT_STATE_FIELD: &'static MessageField = &MessageField {
948            name: "input_state",
949            json_name: "inputState",
950            number: 2i32,
951            message_fields: None,
952        };
953        pub const INPUT_VERSION_FIELD: &'static MessageField = &MessageField {
954            name: "input_version",
955            json_name: "inputVersion",
956            number: 3i32,
957            message_fields: None,
958        };
959        pub const INPUT_DIGEST_FIELD: &'static MessageField = &MessageField {
960            name: "input_digest",
961            json_name: "inputDigest",
962            number: 4i32,
963            message_fields: None,
964        };
965        pub const INPUT_OWNER_FIELD: &'static MessageField = &MessageField {
966            name: "input_owner",
967            json_name: "inputOwner",
968            number: 5i32,
969            message_fields: Some(Owner::FIELDS),
970        };
971        pub const OUTPUT_STATE_FIELD: &'static MessageField = &MessageField {
972            name: "output_state",
973            json_name: "outputState",
974            number: 6i32,
975            message_fields: None,
976        };
977        pub const OUTPUT_VERSION_FIELD: &'static MessageField = &MessageField {
978            name: "output_version",
979            json_name: "outputVersion",
980            number: 7i32,
981            message_fields: None,
982        };
983        pub const OUTPUT_DIGEST_FIELD: &'static MessageField = &MessageField {
984            name: "output_digest",
985            json_name: "outputDigest",
986            number: 8i32,
987            message_fields: None,
988        };
989        pub const OUTPUT_OWNER_FIELD: &'static MessageField = &MessageField {
990            name: "output_owner",
991            json_name: "outputOwner",
992            number: 9i32,
993            message_fields: Some(Owner::FIELDS),
994        };
995        pub const ACCUMULATOR_WRITE_FIELD: &'static MessageField = &MessageField {
996            name: "accumulator_write",
997            json_name: "accumulatorWrite",
998            number: 12i32,
999            message_fields: Some(AccumulatorWrite::FIELDS),
1000        };
1001        pub const ID_OPERATION_FIELD: &'static MessageField = &MessageField {
1002            name: "id_operation",
1003            json_name: "idOperation",
1004            number: 10i32,
1005            message_fields: None,
1006        };
1007        pub const OBJECT_TYPE_FIELD: &'static MessageField = &MessageField {
1008            name: "object_type",
1009            json_name: "objectType",
1010            number: 11i32,
1011            message_fields: None,
1012        };
1013    }
1014    impl MessageFields for ChangedObject {
1015        const FIELDS: &'static [&'static MessageField] = &[
1016            Self::OBJECT_ID_FIELD,
1017            Self::INPUT_STATE_FIELD,
1018            Self::INPUT_VERSION_FIELD,
1019            Self::INPUT_DIGEST_FIELD,
1020            Self::INPUT_OWNER_FIELD,
1021            Self::OUTPUT_STATE_FIELD,
1022            Self::OUTPUT_VERSION_FIELD,
1023            Self::OUTPUT_DIGEST_FIELD,
1024            Self::OUTPUT_OWNER_FIELD,
1025            Self::ACCUMULATOR_WRITE_FIELD,
1026            Self::ID_OPERATION_FIELD,
1027            Self::OBJECT_TYPE_FIELD,
1028        ];
1029    }
1030    impl ChangedObject {
1031        pub fn path_builder() -> ChangedObjectFieldPathBuilder {
1032            ChangedObjectFieldPathBuilder::new()
1033        }
1034    }
1035    pub struct ChangedObjectFieldPathBuilder {
1036        path: Vec<&'static str>,
1037    }
1038    impl ChangedObjectFieldPathBuilder {
1039        #[allow(clippy::new_without_default)]
1040        pub fn new() -> Self {
1041            Self { path: Default::default() }
1042        }
1043        #[doc(hidden)]
1044        pub fn new_with_base(base: Vec<&'static str>) -> Self {
1045            Self { path: base }
1046        }
1047        pub fn finish(self) -> String {
1048            self.path.join(".")
1049        }
1050        pub fn object_id(mut self) -> String {
1051            self.path.push(ChangedObject::OBJECT_ID_FIELD.name);
1052            self.finish()
1053        }
1054        pub fn input_state(mut self) -> String {
1055            self.path.push(ChangedObject::INPUT_STATE_FIELD.name);
1056            self.finish()
1057        }
1058        pub fn input_version(mut self) -> String {
1059            self.path.push(ChangedObject::INPUT_VERSION_FIELD.name);
1060            self.finish()
1061        }
1062        pub fn input_digest(mut self) -> String {
1063            self.path.push(ChangedObject::INPUT_DIGEST_FIELD.name);
1064            self.finish()
1065        }
1066        pub fn input_owner(mut self) -> OwnerFieldPathBuilder {
1067            self.path.push(ChangedObject::INPUT_OWNER_FIELD.name);
1068            OwnerFieldPathBuilder::new_with_base(self.path)
1069        }
1070        pub fn output_state(mut self) -> String {
1071            self.path.push(ChangedObject::OUTPUT_STATE_FIELD.name);
1072            self.finish()
1073        }
1074        pub fn output_version(mut self) -> String {
1075            self.path.push(ChangedObject::OUTPUT_VERSION_FIELD.name);
1076            self.finish()
1077        }
1078        pub fn output_digest(mut self) -> String {
1079            self.path.push(ChangedObject::OUTPUT_DIGEST_FIELD.name);
1080            self.finish()
1081        }
1082        pub fn output_owner(mut self) -> OwnerFieldPathBuilder {
1083            self.path.push(ChangedObject::OUTPUT_OWNER_FIELD.name);
1084            OwnerFieldPathBuilder::new_with_base(self.path)
1085        }
1086        pub fn accumulator_write(mut self) -> AccumulatorWriteFieldPathBuilder {
1087            self.path.push(ChangedObject::ACCUMULATOR_WRITE_FIELD.name);
1088            AccumulatorWriteFieldPathBuilder::new_with_base(self.path)
1089        }
1090        pub fn id_operation(mut self) -> String {
1091            self.path.push(ChangedObject::ID_OPERATION_FIELD.name);
1092            self.finish()
1093        }
1094        pub fn object_type(mut self) -> String {
1095            self.path.push(ChangedObject::OBJECT_TYPE_FIELD.name);
1096            self.finish()
1097        }
1098    }
1099    impl EventDigestEntry {
1100        pub const EVENT_INDEX_FIELD: &'static MessageField = &MessageField {
1101            name: "event_index",
1102            json_name: "eventIndex",
1103            number: 1i32,
1104            message_fields: None,
1105        };
1106        pub const DIGEST_FIELD: &'static MessageField = &MessageField {
1107            name: "digest",
1108            json_name: "digest",
1109            number: 2i32,
1110            message_fields: None,
1111        };
1112    }
1113    impl MessageFields for EventDigestEntry {
1114        const FIELDS: &'static [&'static MessageField] = &[
1115            Self::EVENT_INDEX_FIELD,
1116            Self::DIGEST_FIELD,
1117        ];
1118    }
1119    impl EventDigestEntry {
1120        pub fn path_builder() -> EventDigestEntryFieldPathBuilder {
1121            EventDigestEntryFieldPathBuilder::new()
1122        }
1123    }
1124    pub struct EventDigestEntryFieldPathBuilder {
1125        path: Vec<&'static str>,
1126    }
1127    impl EventDigestEntryFieldPathBuilder {
1128        #[allow(clippy::new_without_default)]
1129        pub fn new() -> Self {
1130            Self { path: Default::default() }
1131        }
1132        #[doc(hidden)]
1133        pub fn new_with_base(base: Vec<&'static str>) -> Self {
1134            Self { path: base }
1135        }
1136        pub fn finish(self) -> String {
1137            self.path.join(".")
1138        }
1139        pub fn event_index(mut self) -> String {
1140            self.path.push(EventDigestEntry::EVENT_INDEX_FIELD.name);
1141            self.finish()
1142        }
1143        pub fn digest(mut self) -> String {
1144            self.path.push(EventDigestEntry::DIGEST_FIELD.name);
1145            self.finish()
1146        }
1147    }
1148    impl AccumulatorWrite {
1149        pub const ADDRESS_FIELD: &'static MessageField = &MessageField {
1150            name: "address",
1151            json_name: "address",
1152            number: 1i32,
1153            message_fields: None,
1154        };
1155        pub const ACCUMULATOR_TYPE_FIELD: &'static MessageField = &MessageField {
1156            name: "accumulator_type",
1157            json_name: "accumulatorType",
1158            number: 2i32,
1159            message_fields: None,
1160        };
1161        pub const OPERATION_FIELD: &'static MessageField = &MessageField {
1162            name: "operation",
1163            json_name: "operation",
1164            number: 3i32,
1165            message_fields: None,
1166        };
1167        pub const VALUE_KIND_FIELD: &'static MessageField = &MessageField {
1168            name: "value_kind",
1169            json_name: "valueKind",
1170            number: 4i32,
1171            message_fields: None,
1172        };
1173        pub const INTEGER_VALUE_FIELD: &'static MessageField = &MessageField {
1174            name: "integer_value",
1175            json_name: "integerValue",
1176            number: 5i32,
1177            message_fields: None,
1178        };
1179        pub const INTEGER_TUPLE_FIELD: &'static MessageField = &MessageField {
1180            name: "integer_tuple",
1181            json_name: "integerTuple",
1182            number: 6i32,
1183            message_fields: None,
1184        };
1185        pub const EVENT_DIGEST_VALUE_FIELD: &'static MessageField = &MessageField {
1186            name: "event_digest_value",
1187            json_name: "eventDigestValue",
1188            number: 7i32,
1189            message_fields: Some(EventDigestEntry::FIELDS),
1190        };
1191    }
1192    impl MessageFields for AccumulatorWrite {
1193        const FIELDS: &'static [&'static MessageField] = &[
1194            Self::ADDRESS_FIELD,
1195            Self::ACCUMULATOR_TYPE_FIELD,
1196            Self::OPERATION_FIELD,
1197            Self::VALUE_KIND_FIELD,
1198            Self::INTEGER_VALUE_FIELD,
1199            Self::INTEGER_TUPLE_FIELD,
1200            Self::EVENT_DIGEST_VALUE_FIELD,
1201        ];
1202    }
1203    impl AccumulatorWrite {
1204        pub fn path_builder() -> AccumulatorWriteFieldPathBuilder {
1205            AccumulatorWriteFieldPathBuilder::new()
1206        }
1207    }
1208    pub struct AccumulatorWriteFieldPathBuilder {
1209        path: Vec<&'static str>,
1210    }
1211    impl AccumulatorWriteFieldPathBuilder {
1212        #[allow(clippy::new_without_default)]
1213        pub fn new() -> Self {
1214            Self { path: Default::default() }
1215        }
1216        #[doc(hidden)]
1217        pub fn new_with_base(base: Vec<&'static str>) -> Self {
1218            Self { path: base }
1219        }
1220        pub fn finish(self) -> String {
1221            self.path.join(".")
1222        }
1223        pub fn address(mut self) -> String {
1224            self.path.push(AccumulatorWrite::ADDRESS_FIELD.name);
1225            self.finish()
1226        }
1227        pub fn accumulator_type(mut self) -> String {
1228            self.path.push(AccumulatorWrite::ACCUMULATOR_TYPE_FIELD.name);
1229            self.finish()
1230        }
1231        pub fn operation(mut self) -> String {
1232            self.path.push(AccumulatorWrite::OPERATION_FIELD.name);
1233            self.finish()
1234        }
1235        pub fn value_kind(mut self) -> String {
1236            self.path.push(AccumulatorWrite::VALUE_KIND_FIELD.name);
1237            self.finish()
1238        }
1239        pub fn integer_value(mut self) -> String {
1240            self.path.push(AccumulatorWrite::INTEGER_VALUE_FIELD.name);
1241            self.finish()
1242        }
1243        pub fn integer_tuple(mut self) -> String {
1244            self.path.push(AccumulatorWrite::INTEGER_TUPLE_FIELD.name);
1245            self.finish()
1246        }
1247        pub fn event_digest_value(mut self) -> EventDigestEntryFieldPathBuilder {
1248            self.path.push(AccumulatorWrite::EVENT_DIGEST_VALUE_FIELD.name);
1249            EventDigestEntryFieldPathBuilder::new_with_base(self.path)
1250        }
1251    }
1252    impl UnchangedConsensusObject {
1253        pub const KIND_FIELD: &'static MessageField = &MessageField {
1254            name: "kind",
1255            json_name: "kind",
1256            number: 1i32,
1257            message_fields: None,
1258        };
1259        pub const OBJECT_ID_FIELD: &'static MessageField = &MessageField {
1260            name: "object_id",
1261            json_name: "objectId",
1262            number: 2i32,
1263            message_fields: None,
1264        };
1265        pub const VERSION_FIELD: &'static MessageField = &MessageField {
1266            name: "version",
1267            json_name: "version",
1268            number: 3i32,
1269            message_fields: None,
1270        };
1271        pub const DIGEST_FIELD: &'static MessageField = &MessageField {
1272            name: "digest",
1273            json_name: "digest",
1274            number: 4i32,
1275            message_fields: None,
1276        };
1277        pub const OBJECT_TYPE_FIELD: &'static MessageField = &MessageField {
1278            name: "object_type",
1279            json_name: "objectType",
1280            number: 5i32,
1281            message_fields: None,
1282        };
1283    }
1284    impl MessageFields for UnchangedConsensusObject {
1285        const FIELDS: &'static [&'static MessageField] = &[
1286            Self::KIND_FIELD,
1287            Self::OBJECT_ID_FIELD,
1288            Self::VERSION_FIELD,
1289            Self::DIGEST_FIELD,
1290            Self::OBJECT_TYPE_FIELD,
1291        ];
1292    }
1293    impl UnchangedConsensusObject {
1294        pub fn path_builder() -> UnchangedConsensusObjectFieldPathBuilder {
1295            UnchangedConsensusObjectFieldPathBuilder::new()
1296        }
1297    }
1298    pub struct UnchangedConsensusObjectFieldPathBuilder {
1299        path: Vec<&'static str>,
1300    }
1301    impl UnchangedConsensusObjectFieldPathBuilder {
1302        #[allow(clippy::new_without_default)]
1303        pub fn new() -> Self {
1304            Self { path: Default::default() }
1305        }
1306        #[doc(hidden)]
1307        pub fn new_with_base(base: Vec<&'static str>) -> Self {
1308            Self { path: base }
1309        }
1310        pub fn finish(self) -> String {
1311            self.path.join(".")
1312        }
1313        pub fn kind(mut self) -> String {
1314            self.path.push(UnchangedConsensusObject::KIND_FIELD.name);
1315            self.finish()
1316        }
1317        pub fn object_id(mut self) -> String {
1318            self.path.push(UnchangedConsensusObject::OBJECT_ID_FIELD.name);
1319            self.finish()
1320        }
1321        pub fn version(mut self) -> String {
1322            self.path.push(UnchangedConsensusObject::VERSION_FIELD.name);
1323            self.finish()
1324        }
1325        pub fn digest(mut self) -> String {
1326            self.path.push(UnchangedConsensusObject::DIGEST_FIELD.name);
1327            self.finish()
1328        }
1329        pub fn object_type(mut self) -> String {
1330            self.path.push(UnchangedConsensusObject::OBJECT_TYPE_FIELD.name);
1331            self.finish()
1332        }
1333    }
1334    impl Epoch {
1335        pub const EPOCH_FIELD: &'static MessageField = &MessageField {
1336            name: "epoch",
1337            json_name: "epoch",
1338            number: 1i32,
1339            message_fields: None,
1340        };
1341        pub const COMMITTEE_FIELD: &'static MessageField = &MessageField {
1342            name: "committee",
1343            json_name: "committee",
1344            number: 2i32,
1345            message_fields: Some(ValidatorCommittee::FIELDS),
1346        };
1347        pub const SYSTEM_STATE_FIELD: &'static MessageField = &MessageField {
1348            name: "system_state",
1349            json_name: "systemState",
1350            number: 3i32,
1351            message_fields: Some(SystemState::FIELDS),
1352        };
1353        pub const FIRST_CHECKPOINT_FIELD: &'static MessageField = &MessageField {
1354            name: "first_checkpoint",
1355            json_name: "firstCheckpoint",
1356            number: 4i32,
1357            message_fields: None,
1358        };
1359        pub const LAST_CHECKPOINT_FIELD: &'static MessageField = &MessageField {
1360            name: "last_checkpoint",
1361            json_name: "lastCheckpoint",
1362            number: 5i32,
1363            message_fields: None,
1364        };
1365        pub const START_FIELD: &'static MessageField = &MessageField {
1366            name: "start",
1367            json_name: "start",
1368            number: 6i32,
1369            message_fields: None,
1370        };
1371        pub const END_FIELD: &'static MessageField = &MessageField {
1372            name: "end",
1373            json_name: "end",
1374            number: 7i32,
1375            message_fields: None,
1376        };
1377        pub const REFERENCE_GAS_PRICE_FIELD: &'static MessageField = &MessageField {
1378            name: "reference_gas_price",
1379            json_name: "referenceGasPrice",
1380            number: 8i32,
1381            message_fields: None,
1382        };
1383        pub const PROTOCOL_CONFIG_FIELD: &'static MessageField = &MessageField {
1384            name: "protocol_config",
1385            json_name: "protocolConfig",
1386            number: 9i32,
1387            message_fields: Some(ProtocolConfig::FIELDS),
1388        };
1389        pub const TRANSACTION_START_INCLUSIVE_FIELD: &'static MessageField = &MessageField {
1390            name: "transaction_start_inclusive",
1391            json_name: "transactionStartInclusive",
1392            number: 10i32,
1393            message_fields: None,
1394        };
1395        pub const TRANSACTION_END_EXCLUSIVE_FIELD: &'static MessageField = &MessageField {
1396            name: "transaction_end_exclusive",
1397            json_name: "transactionEndExclusive",
1398            number: 11i32,
1399            message_fields: None,
1400        };
1401        pub const ENDED_IN_SAFE_MODE_FIELD: &'static MessageField = &MessageField {
1402            name: "ended_in_safe_mode",
1403            json_name: "endedInSafeMode",
1404            number: 12i32,
1405            message_fields: None,
1406        };
1407        pub const SYSTEM_EPOCH_INFO_FIELD: &'static MessageField = &MessageField {
1408            name: "system_epoch_info",
1409            json_name: "systemEpochInfo",
1410            number: 13i32,
1411            message_fields: Some(SystemEpochInfo::FIELDS),
1412        };
1413        pub const EPOCH_COMMITMENTS_FIELD: &'static MessageField = &MessageField {
1414            name: "epoch_commitments",
1415            json_name: "epochCommitments",
1416            number: 14i32,
1417            message_fields: Some(CheckpointCommitment::FIELDS),
1418        };
1419    }
1420    impl MessageFields for Epoch {
1421        const FIELDS: &'static [&'static MessageField] = &[
1422            Self::EPOCH_FIELD,
1423            Self::COMMITTEE_FIELD,
1424            Self::SYSTEM_STATE_FIELD,
1425            Self::FIRST_CHECKPOINT_FIELD,
1426            Self::LAST_CHECKPOINT_FIELD,
1427            Self::START_FIELD,
1428            Self::END_FIELD,
1429            Self::REFERENCE_GAS_PRICE_FIELD,
1430            Self::PROTOCOL_CONFIG_FIELD,
1431            Self::TRANSACTION_START_INCLUSIVE_FIELD,
1432            Self::TRANSACTION_END_EXCLUSIVE_FIELD,
1433            Self::ENDED_IN_SAFE_MODE_FIELD,
1434            Self::SYSTEM_EPOCH_INFO_FIELD,
1435            Self::EPOCH_COMMITMENTS_FIELD,
1436        ];
1437    }
1438    impl Epoch {
1439        pub fn path_builder() -> EpochFieldPathBuilder {
1440            EpochFieldPathBuilder::new()
1441        }
1442    }
1443    pub struct EpochFieldPathBuilder {
1444        path: Vec<&'static str>,
1445    }
1446    impl EpochFieldPathBuilder {
1447        #[allow(clippy::new_without_default)]
1448        pub fn new() -> Self {
1449            Self { path: Default::default() }
1450        }
1451        #[doc(hidden)]
1452        pub fn new_with_base(base: Vec<&'static str>) -> Self {
1453            Self { path: base }
1454        }
1455        pub fn finish(self) -> String {
1456            self.path.join(".")
1457        }
1458        pub fn epoch(mut self) -> String {
1459            self.path.push(Epoch::EPOCH_FIELD.name);
1460            self.finish()
1461        }
1462        pub fn committee(mut self) -> ValidatorCommitteeFieldPathBuilder {
1463            self.path.push(Epoch::COMMITTEE_FIELD.name);
1464            ValidatorCommitteeFieldPathBuilder::new_with_base(self.path)
1465        }
1466        pub fn system_state(mut self) -> SystemStateFieldPathBuilder {
1467            self.path.push(Epoch::SYSTEM_STATE_FIELD.name);
1468            SystemStateFieldPathBuilder::new_with_base(self.path)
1469        }
1470        pub fn first_checkpoint(mut self) -> String {
1471            self.path.push(Epoch::FIRST_CHECKPOINT_FIELD.name);
1472            self.finish()
1473        }
1474        pub fn last_checkpoint(mut self) -> String {
1475            self.path.push(Epoch::LAST_CHECKPOINT_FIELD.name);
1476            self.finish()
1477        }
1478        pub fn start(mut self) -> String {
1479            self.path.push(Epoch::START_FIELD.name);
1480            self.finish()
1481        }
1482        pub fn end(mut self) -> String {
1483            self.path.push(Epoch::END_FIELD.name);
1484            self.finish()
1485        }
1486        pub fn reference_gas_price(mut self) -> String {
1487            self.path.push(Epoch::REFERENCE_GAS_PRICE_FIELD.name);
1488            self.finish()
1489        }
1490        pub fn protocol_config(mut self) -> ProtocolConfigFieldPathBuilder {
1491            self.path.push(Epoch::PROTOCOL_CONFIG_FIELD.name);
1492            ProtocolConfigFieldPathBuilder::new_with_base(self.path)
1493        }
1494        pub fn transaction_start_inclusive(mut self) -> String {
1495            self.path.push(Epoch::TRANSACTION_START_INCLUSIVE_FIELD.name);
1496            self.finish()
1497        }
1498        pub fn transaction_end_exclusive(mut self) -> String {
1499            self.path.push(Epoch::TRANSACTION_END_EXCLUSIVE_FIELD.name);
1500            self.finish()
1501        }
1502        pub fn ended_in_safe_mode(mut self) -> String {
1503            self.path.push(Epoch::ENDED_IN_SAFE_MODE_FIELD.name);
1504            self.finish()
1505        }
1506        pub fn system_epoch_info(mut self) -> SystemEpochInfoFieldPathBuilder {
1507            self.path.push(Epoch::SYSTEM_EPOCH_INFO_FIELD.name);
1508            SystemEpochInfoFieldPathBuilder::new_with_base(self.path)
1509        }
1510        pub fn epoch_commitments(mut self) -> CheckpointCommitmentFieldPathBuilder {
1511            self.path.push(Epoch::EPOCH_COMMITMENTS_FIELD.name);
1512            CheckpointCommitmentFieldPathBuilder::new_with_base(self.path)
1513        }
1514    }
1515    impl SystemEpochInfo {
1516        pub const TOTAL_STAKE_FIELD: &'static MessageField = &MessageField {
1517            name: "total_stake",
1518            json_name: "totalStake",
1519            number: 1i32,
1520            message_fields: None,
1521        };
1522        pub const STORAGE_FUND_REINVESTMENT_FIELD: &'static MessageField = &MessageField {
1523            name: "storage_fund_reinvestment",
1524            json_name: "storageFundReinvestment",
1525            number: 2i32,
1526            message_fields: None,
1527        };
1528        pub const STORAGE_CHARGE_FIELD: &'static MessageField = &MessageField {
1529            name: "storage_charge",
1530            json_name: "storageCharge",
1531            number: 3i32,
1532            message_fields: None,
1533        };
1534        pub const STORAGE_REBATE_FIELD: &'static MessageField = &MessageField {
1535            name: "storage_rebate",
1536            json_name: "storageRebate",
1537            number: 4i32,
1538            message_fields: None,
1539        };
1540        pub const STORAGE_FUND_BALANCE_FIELD: &'static MessageField = &MessageField {
1541            name: "storage_fund_balance",
1542            json_name: "storageFundBalance",
1543            number: 5i32,
1544            message_fields: None,
1545        };
1546        pub const STAKE_SUBSIDY_AMOUNT_FIELD: &'static MessageField = &MessageField {
1547            name: "stake_subsidy_amount",
1548            json_name: "stakeSubsidyAmount",
1549            number: 6i32,
1550            message_fields: None,
1551        };
1552        pub const TOTAL_GAS_FEES_FIELD: &'static MessageField = &MessageField {
1553            name: "total_gas_fees",
1554            json_name: "totalGasFees",
1555            number: 7i32,
1556            message_fields: None,
1557        };
1558        pub const TOTAL_STAKE_REWARDS_DISTRIBUTED_FIELD: &'static MessageField = &MessageField {
1559            name: "total_stake_rewards_distributed",
1560            json_name: "totalStakeRewardsDistributed",
1561            number: 8i32,
1562            message_fields: None,
1563        };
1564        pub const LEFTOVER_STORAGE_FUND_INFLOW_FIELD: &'static MessageField = &MessageField {
1565            name: "leftover_storage_fund_inflow",
1566            json_name: "leftoverStorageFundInflow",
1567            number: 9i32,
1568            message_fields: None,
1569        };
1570    }
1571    impl MessageFields for SystemEpochInfo {
1572        const FIELDS: &'static [&'static MessageField] = &[
1573            Self::TOTAL_STAKE_FIELD,
1574            Self::STORAGE_FUND_REINVESTMENT_FIELD,
1575            Self::STORAGE_CHARGE_FIELD,
1576            Self::STORAGE_REBATE_FIELD,
1577            Self::STORAGE_FUND_BALANCE_FIELD,
1578            Self::STAKE_SUBSIDY_AMOUNT_FIELD,
1579            Self::TOTAL_GAS_FEES_FIELD,
1580            Self::TOTAL_STAKE_REWARDS_DISTRIBUTED_FIELD,
1581            Self::LEFTOVER_STORAGE_FUND_INFLOW_FIELD,
1582        ];
1583    }
1584    impl SystemEpochInfo {
1585        pub fn path_builder() -> SystemEpochInfoFieldPathBuilder {
1586            SystemEpochInfoFieldPathBuilder::new()
1587        }
1588    }
1589    pub struct SystemEpochInfoFieldPathBuilder {
1590        path: Vec<&'static str>,
1591    }
1592    impl SystemEpochInfoFieldPathBuilder {
1593        #[allow(clippy::new_without_default)]
1594        pub fn new() -> Self {
1595            Self { path: Default::default() }
1596        }
1597        #[doc(hidden)]
1598        pub fn new_with_base(base: Vec<&'static str>) -> Self {
1599            Self { path: base }
1600        }
1601        pub fn finish(self) -> String {
1602            self.path.join(".")
1603        }
1604        pub fn total_stake(mut self) -> String {
1605            self.path.push(SystemEpochInfo::TOTAL_STAKE_FIELD.name);
1606            self.finish()
1607        }
1608        pub fn storage_fund_reinvestment(mut self) -> String {
1609            self.path.push(SystemEpochInfo::STORAGE_FUND_REINVESTMENT_FIELD.name);
1610            self.finish()
1611        }
1612        pub fn storage_charge(mut self) -> String {
1613            self.path.push(SystemEpochInfo::STORAGE_CHARGE_FIELD.name);
1614            self.finish()
1615        }
1616        pub fn storage_rebate(mut self) -> String {
1617            self.path.push(SystemEpochInfo::STORAGE_REBATE_FIELD.name);
1618            self.finish()
1619        }
1620        pub fn storage_fund_balance(mut self) -> String {
1621            self.path.push(SystemEpochInfo::STORAGE_FUND_BALANCE_FIELD.name);
1622            self.finish()
1623        }
1624        pub fn stake_subsidy_amount(mut self) -> String {
1625            self.path.push(SystemEpochInfo::STAKE_SUBSIDY_AMOUNT_FIELD.name);
1626            self.finish()
1627        }
1628        pub fn total_gas_fees(mut self) -> String {
1629            self.path.push(SystemEpochInfo::TOTAL_GAS_FEES_FIELD.name);
1630            self.finish()
1631        }
1632        pub fn total_stake_rewards_distributed(mut self) -> String {
1633            self.path.push(SystemEpochInfo::TOTAL_STAKE_REWARDS_DISTRIBUTED_FIELD.name);
1634            self.finish()
1635        }
1636        pub fn leftover_storage_fund_inflow(mut self) -> String {
1637            self.path.push(SystemEpochInfo::LEFTOVER_STORAGE_FUND_INFLOW_FIELD.name);
1638            self.finish()
1639        }
1640    }
1641    impl TransactionEvents {
1642        pub const BCS_FIELD: &'static MessageField = &MessageField {
1643            name: "bcs",
1644            json_name: "bcs",
1645            number: 1i32,
1646            message_fields: Some(Bcs::FIELDS),
1647        };
1648        pub const DIGEST_FIELD: &'static MessageField = &MessageField {
1649            name: "digest",
1650            json_name: "digest",
1651            number: 2i32,
1652            message_fields: None,
1653        };
1654        pub const EVENTS_FIELD: &'static MessageField = &MessageField {
1655            name: "events",
1656            json_name: "events",
1657            number: 3i32,
1658            message_fields: Some(Event::FIELDS),
1659        };
1660    }
1661    impl MessageFields for TransactionEvents {
1662        const FIELDS: &'static [&'static MessageField] = &[
1663            Self::BCS_FIELD,
1664            Self::DIGEST_FIELD,
1665            Self::EVENTS_FIELD,
1666        ];
1667    }
1668    impl TransactionEvents {
1669        pub fn path_builder() -> TransactionEventsFieldPathBuilder {
1670            TransactionEventsFieldPathBuilder::new()
1671        }
1672    }
1673    pub struct TransactionEventsFieldPathBuilder {
1674        path: Vec<&'static str>,
1675    }
1676    impl TransactionEventsFieldPathBuilder {
1677        #[allow(clippy::new_without_default)]
1678        pub fn new() -> Self {
1679            Self { path: Default::default() }
1680        }
1681        #[doc(hidden)]
1682        pub fn new_with_base(base: Vec<&'static str>) -> Self {
1683            Self { path: base }
1684        }
1685        pub fn finish(self) -> String {
1686            self.path.join(".")
1687        }
1688        pub fn bcs(mut self) -> BcsFieldPathBuilder {
1689            self.path.push(TransactionEvents::BCS_FIELD.name);
1690            BcsFieldPathBuilder::new_with_base(self.path)
1691        }
1692        pub fn digest(mut self) -> String {
1693            self.path.push(TransactionEvents::DIGEST_FIELD.name);
1694            self.finish()
1695        }
1696        pub fn events(mut self) -> EventFieldPathBuilder {
1697            self.path.push(TransactionEvents::EVENTS_FIELD.name);
1698            EventFieldPathBuilder::new_with_base(self.path)
1699        }
1700    }
1701    impl Event {
1702        pub const PACKAGE_ID_FIELD: &'static MessageField = &MessageField {
1703            name: "package_id",
1704            json_name: "packageId",
1705            number: 1i32,
1706            message_fields: None,
1707        };
1708        pub const MODULE_FIELD: &'static MessageField = &MessageField {
1709            name: "module",
1710            json_name: "module",
1711            number: 2i32,
1712            message_fields: None,
1713        };
1714        pub const SENDER_FIELD: &'static MessageField = &MessageField {
1715            name: "sender",
1716            json_name: "sender",
1717            number: 3i32,
1718            message_fields: None,
1719        };
1720        pub const EVENT_TYPE_FIELD: &'static MessageField = &MessageField {
1721            name: "event_type",
1722            json_name: "eventType",
1723            number: 4i32,
1724            message_fields: None,
1725        };
1726        pub const CONTENTS_FIELD: &'static MessageField = &MessageField {
1727            name: "contents",
1728            json_name: "contents",
1729            number: 5i32,
1730            message_fields: Some(Bcs::FIELDS),
1731        };
1732        pub const JSON_FIELD: &'static MessageField = &MessageField {
1733            name: "json",
1734            json_name: "json",
1735            number: 6i32,
1736            message_fields: None,
1737        };
1738        pub const CHECKPOINT_FIELD: &'static MessageField = &MessageField {
1739            name: "checkpoint",
1740            json_name: "checkpoint",
1741            number: 7i32,
1742            message_fields: None,
1743        };
1744        pub const TRANSACTION_DIGEST_FIELD: &'static MessageField = &MessageField {
1745            name: "transaction_digest",
1746            json_name: "transactionDigest",
1747            number: 8i32,
1748            message_fields: None,
1749        };
1750        pub const TRANSACTION_INDEX_FIELD: &'static MessageField = &MessageField {
1751            name: "transaction_index",
1752            json_name: "transactionIndex",
1753            number: 9i32,
1754            message_fields: None,
1755        };
1756        pub const EVENT_INDEX_FIELD: &'static MessageField = &MessageField {
1757            name: "event_index",
1758            json_name: "eventIndex",
1759            number: 10i32,
1760            message_fields: None,
1761        };
1762    }
1763    impl MessageFields for Event {
1764        const FIELDS: &'static [&'static MessageField] = &[
1765            Self::PACKAGE_ID_FIELD,
1766            Self::MODULE_FIELD,
1767            Self::SENDER_FIELD,
1768            Self::EVENT_TYPE_FIELD,
1769            Self::CONTENTS_FIELD,
1770            Self::JSON_FIELD,
1771            Self::CHECKPOINT_FIELD,
1772            Self::TRANSACTION_DIGEST_FIELD,
1773            Self::TRANSACTION_INDEX_FIELD,
1774            Self::EVENT_INDEX_FIELD,
1775        ];
1776    }
1777    impl Event {
1778        pub fn path_builder() -> EventFieldPathBuilder {
1779            EventFieldPathBuilder::new()
1780        }
1781    }
1782    pub struct EventFieldPathBuilder {
1783        path: Vec<&'static str>,
1784    }
1785    impl EventFieldPathBuilder {
1786        #[allow(clippy::new_without_default)]
1787        pub fn new() -> Self {
1788            Self { path: Default::default() }
1789        }
1790        #[doc(hidden)]
1791        pub fn new_with_base(base: Vec<&'static str>) -> Self {
1792            Self { path: base }
1793        }
1794        pub fn finish(self) -> String {
1795            self.path.join(".")
1796        }
1797        pub fn package_id(mut self) -> String {
1798            self.path.push(Event::PACKAGE_ID_FIELD.name);
1799            self.finish()
1800        }
1801        pub fn module(mut self) -> String {
1802            self.path.push(Event::MODULE_FIELD.name);
1803            self.finish()
1804        }
1805        pub fn sender(mut self) -> String {
1806            self.path.push(Event::SENDER_FIELD.name);
1807            self.finish()
1808        }
1809        pub fn event_type(mut self) -> String {
1810            self.path.push(Event::EVENT_TYPE_FIELD.name);
1811            self.finish()
1812        }
1813        pub fn contents(mut self) -> BcsFieldPathBuilder {
1814            self.path.push(Event::CONTENTS_FIELD.name);
1815            BcsFieldPathBuilder::new_with_base(self.path)
1816        }
1817        pub fn json(mut self) -> String {
1818            self.path.push(Event::JSON_FIELD.name);
1819            self.finish()
1820        }
1821        pub fn checkpoint(mut self) -> String {
1822            self.path.push(Event::CHECKPOINT_FIELD.name);
1823            self.finish()
1824        }
1825        pub fn transaction_digest(mut self) -> String {
1826            self.path.push(Event::TRANSACTION_DIGEST_FIELD.name);
1827            self.finish()
1828        }
1829        pub fn transaction_index(mut self) -> String {
1830            self.path.push(Event::TRANSACTION_INDEX_FIELD.name);
1831            self.finish()
1832        }
1833        pub fn event_index(mut self) -> String {
1834            self.path.push(Event::EVENT_INDEX_FIELD.name);
1835            self.finish()
1836        }
1837    }
1838    impl ExecutedTransaction {
1839        pub const DIGEST_FIELD: &'static MessageField = &MessageField {
1840            name: "digest",
1841            json_name: "digest",
1842            number: 1i32,
1843            message_fields: None,
1844        };
1845        pub const TRANSACTION_FIELD: &'static MessageField = &MessageField {
1846            name: "transaction",
1847            json_name: "transaction",
1848            number: 2i32,
1849            message_fields: Some(Transaction::FIELDS),
1850        };
1851        pub const SIGNATURES_FIELD: &'static MessageField = &MessageField {
1852            name: "signatures",
1853            json_name: "signatures",
1854            number: 3i32,
1855            message_fields: Some(UserSignature::FIELDS),
1856        };
1857        pub const EFFECTS_FIELD: &'static MessageField = &MessageField {
1858            name: "effects",
1859            json_name: "effects",
1860            number: 4i32,
1861            message_fields: Some(TransactionEffects::FIELDS),
1862        };
1863        pub const EVENTS_FIELD: &'static MessageField = &MessageField {
1864            name: "events",
1865            json_name: "events",
1866            number: 5i32,
1867            message_fields: Some(TransactionEvents::FIELDS),
1868        };
1869        pub const CHECKPOINT_FIELD: &'static MessageField = &MessageField {
1870            name: "checkpoint",
1871            json_name: "checkpoint",
1872            number: 6i32,
1873            message_fields: None,
1874        };
1875        pub const TIMESTAMP_FIELD: &'static MessageField = &MessageField {
1876            name: "timestamp",
1877            json_name: "timestamp",
1878            number: 7i32,
1879            message_fields: None,
1880        };
1881        pub const BALANCE_CHANGES_FIELD: &'static MessageField = &MessageField {
1882            name: "balance_changes",
1883            json_name: "balanceChanges",
1884            number: 8i32,
1885            message_fields: Some(BalanceChange::FIELDS),
1886        };
1887        pub const OBJECTS_FIELD: &'static MessageField = &MessageField {
1888            name: "objects",
1889            json_name: "objects",
1890            number: 9i32,
1891            message_fields: Some(ObjectSet::FIELDS),
1892        };
1893        pub const TRANSACTION_INDEX_FIELD: &'static MessageField = &MessageField {
1894            name: "transaction_index",
1895            json_name: "transactionIndex",
1896            number: 10i32,
1897            message_fields: None,
1898        };
1899    }
1900    impl MessageFields for ExecutedTransaction {
1901        const FIELDS: &'static [&'static MessageField] = &[
1902            Self::DIGEST_FIELD,
1903            Self::TRANSACTION_FIELD,
1904            Self::SIGNATURES_FIELD,
1905            Self::EFFECTS_FIELD,
1906            Self::EVENTS_FIELD,
1907            Self::CHECKPOINT_FIELD,
1908            Self::TIMESTAMP_FIELD,
1909            Self::BALANCE_CHANGES_FIELD,
1910            Self::OBJECTS_FIELD,
1911            Self::TRANSACTION_INDEX_FIELD,
1912        ];
1913    }
1914    impl ExecutedTransaction {
1915        pub fn path_builder() -> ExecutedTransactionFieldPathBuilder {
1916            ExecutedTransactionFieldPathBuilder::new()
1917        }
1918    }
1919    pub struct ExecutedTransactionFieldPathBuilder {
1920        path: Vec<&'static str>,
1921    }
1922    impl ExecutedTransactionFieldPathBuilder {
1923        #[allow(clippy::new_without_default)]
1924        pub fn new() -> Self {
1925            Self { path: Default::default() }
1926        }
1927        #[doc(hidden)]
1928        pub fn new_with_base(base: Vec<&'static str>) -> Self {
1929            Self { path: base }
1930        }
1931        pub fn finish(self) -> String {
1932            self.path.join(".")
1933        }
1934        pub fn digest(mut self) -> String {
1935            self.path.push(ExecutedTransaction::DIGEST_FIELD.name);
1936            self.finish()
1937        }
1938        pub fn transaction(mut self) -> TransactionFieldPathBuilder {
1939            self.path.push(ExecutedTransaction::TRANSACTION_FIELD.name);
1940            TransactionFieldPathBuilder::new_with_base(self.path)
1941        }
1942        pub fn signatures(mut self) -> UserSignatureFieldPathBuilder {
1943            self.path.push(ExecutedTransaction::SIGNATURES_FIELD.name);
1944            UserSignatureFieldPathBuilder::new_with_base(self.path)
1945        }
1946        pub fn effects(mut self) -> TransactionEffectsFieldPathBuilder {
1947            self.path.push(ExecutedTransaction::EFFECTS_FIELD.name);
1948            TransactionEffectsFieldPathBuilder::new_with_base(self.path)
1949        }
1950        pub fn events(mut self) -> TransactionEventsFieldPathBuilder {
1951            self.path.push(ExecutedTransaction::EVENTS_FIELD.name);
1952            TransactionEventsFieldPathBuilder::new_with_base(self.path)
1953        }
1954        pub fn checkpoint(mut self) -> String {
1955            self.path.push(ExecutedTransaction::CHECKPOINT_FIELD.name);
1956            self.finish()
1957        }
1958        pub fn timestamp(mut self) -> String {
1959            self.path.push(ExecutedTransaction::TIMESTAMP_FIELD.name);
1960            self.finish()
1961        }
1962        pub fn balance_changes(mut self) -> BalanceChangeFieldPathBuilder {
1963            self.path.push(ExecutedTransaction::BALANCE_CHANGES_FIELD.name);
1964            BalanceChangeFieldPathBuilder::new_with_base(self.path)
1965        }
1966        pub fn objects(mut self) -> ObjectSetFieldPathBuilder {
1967            self.path.push(ExecutedTransaction::OBJECTS_FIELD.name);
1968            ObjectSetFieldPathBuilder::new_with_base(self.path)
1969        }
1970        pub fn transaction_index(mut self) -> String {
1971            self.path.push(ExecutedTransaction::TRANSACTION_INDEX_FIELD.name);
1972            self.finish()
1973        }
1974    }
1975    impl ExecutionStatus {
1976        pub const SUCCESS_FIELD: &'static MessageField = &MessageField {
1977            name: "success",
1978            json_name: "success",
1979            number: 1i32,
1980            message_fields: None,
1981        };
1982        pub const ERROR_FIELD: &'static MessageField = &MessageField {
1983            name: "error",
1984            json_name: "error",
1985            number: 2i32,
1986            message_fields: Some(ExecutionError::FIELDS),
1987        };
1988    }
1989    impl MessageFields for ExecutionStatus {
1990        const FIELDS: &'static [&'static MessageField] = &[
1991            Self::SUCCESS_FIELD,
1992            Self::ERROR_FIELD,
1993        ];
1994    }
1995    impl ExecutionStatus {
1996        pub fn path_builder() -> ExecutionStatusFieldPathBuilder {
1997            ExecutionStatusFieldPathBuilder::new()
1998        }
1999    }
2000    pub struct ExecutionStatusFieldPathBuilder {
2001        path: Vec<&'static str>,
2002    }
2003    impl ExecutionStatusFieldPathBuilder {
2004        #[allow(clippy::new_without_default)]
2005        pub fn new() -> Self {
2006            Self { path: Default::default() }
2007        }
2008        #[doc(hidden)]
2009        pub fn new_with_base(base: Vec<&'static str>) -> Self {
2010            Self { path: base }
2011        }
2012        pub fn finish(self) -> String {
2013            self.path.join(".")
2014        }
2015        pub fn success(mut self) -> String {
2016            self.path.push(ExecutionStatus::SUCCESS_FIELD.name);
2017            self.finish()
2018        }
2019        pub fn error(mut self) -> ExecutionErrorFieldPathBuilder {
2020            self.path.push(ExecutionStatus::ERROR_FIELD.name);
2021            ExecutionErrorFieldPathBuilder::new_with_base(self.path)
2022        }
2023    }
2024    impl ExecutionError {
2025        pub const DESCRIPTION_FIELD: &'static MessageField = &MessageField {
2026            name: "description",
2027            json_name: "description",
2028            number: 1i32,
2029            message_fields: None,
2030        };
2031        pub const COMMAND_FIELD: &'static MessageField = &MessageField {
2032            name: "command",
2033            json_name: "command",
2034            number: 2i32,
2035            message_fields: None,
2036        };
2037        pub const KIND_FIELD: &'static MessageField = &MessageField {
2038            name: "kind",
2039            json_name: "kind",
2040            number: 3i32,
2041            message_fields: None,
2042        };
2043        pub const ABORT_FIELD: &'static MessageField = &MessageField {
2044            name: "abort",
2045            json_name: "abort",
2046            number: 4i32,
2047            message_fields: Some(MoveAbort::FIELDS),
2048        };
2049        pub const SIZE_ERROR_FIELD: &'static MessageField = &MessageField {
2050            name: "size_error",
2051            json_name: "sizeError",
2052            number: 5i32,
2053            message_fields: Some(SizeError::FIELDS),
2054        };
2055        pub const COMMAND_ARGUMENT_ERROR_FIELD: &'static MessageField = &MessageField {
2056            name: "command_argument_error",
2057            json_name: "commandArgumentError",
2058            number: 6i32,
2059            message_fields: Some(CommandArgumentError::FIELDS),
2060        };
2061        pub const TYPE_ARGUMENT_ERROR_FIELD: &'static MessageField = &MessageField {
2062            name: "type_argument_error",
2063            json_name: "typeArgumentError",
2064            number: 7i32,
2065            message_fields: Some(TypeArgumentError::FIELDS),
2066        };
2067        pub const PACKAGE_UPGRADE_ERROR_FIELD: &'static MessageField = &MessageField {
2068            name: "package_upgrade_error",
2069            json_name: "packageUpgradeError",
2070            number: 8i32,
2071            message_fields: Some(PackageUpgradeError::FIELDS),
2072        };
2073        pub const INDEX_ERROR_FIELD: &'static MessageField = &MessageField {
2074            name: "index_error",
2075            json_name: "indexError",
2076            number: 9i32,
2077            message_fields: Some(IndexError::FIELDS),
2078        };
2079        pub const OBJECT_ID_FIELD: &'static MessageField = &MessageField {
2080            name: "object_id",
2081            json_name: "objectId",
2082            number: 10i32,
2083            message_fields: None,
2084        };
2085        pub const COIN_DENY_LIST_ERROR_FIELD: &'static MessageField = &MessageField {
2086            name: "coin_deny_list_error",
2087            json_name: "coinDenyListError",
2088            number: 11i32,
2089            message_fields: Some(CoinDenyListError::FIELDS),
2090        };
2091        pub const CONGESTED_OBJECTS_FIELD: &'static MessageField = &MessageField {
2092            name: "congested_objects",
2093            json_name: "congestedObjects",
2094            number: 12i32,
2095            message_fields: Some(CongestedObjects::FIELDS),
2096        };
2097    }
2098    impl MessageFields for ExecutionError {
2099        const FIELDS: &'static [&'static MessageField] = &[
2100            Self::DESCRIPTION_FIELD,
2101            Self::COMMAND_FIELD,
2102            Self::KIND_FIELD,
2103            Self::ABORT_FIELD,
2104            Self::SIZE_ERROR_FIELD,
2105            Self::COMMAND_ARGUMENT_ERROR_FIELD,
2106            Self::TYPE_ARGUMENT_ERROR_FIELD,
2107            Self::PACKAGE_UPGRADE_ERROR_FIELD,
2108            Self::INDEX_ERROR_FIELD,
2109            Self::OBJECT_ID_FIELD,
2110            Self::COIN_DENY_LIST_ERROR_FIELD,
2111            Self::CONGESTED_OBJECTS_FIELD,
2112        ];
2113    }
2114    impl ExecutionError {
2115        pub fn path_builder() -> ExecutionErrorFieldPathBuilder {
2116            ExecutionErrorFieldPathBuilder::new()
2117        }
2118    }
2119    pub struct ExecutionErrorFieldPathBuilder {
2120        path: Vec<&'static str>,
2121    }
2122    impl ExecutionErrorFieldPathBuilder {
2123        #[allow(clippy::new_without_default)]
2124        pub fn new() -> Self {
2125            Self { path: Default::default() }
2126        }
2127        #[doc(hidden)]
2128        pub fn new_with_base(base: Vec<&'static str>) -> Self {
2129            Self { path: base }
2130        }
2131        pub fn finish(self) -> String {
2132            self.path.join(".")
2133        }
2134        pub fn description(mut self) -> String {
2135            self.path.push(ExecutionError::DESCRIPTION_FIELD.name);
2136            self.finish()
2137        }
2138        pub fn command(mut self) -> String {
2139            self.path.push(ExecutionError::COMMAND_FIELD.name);
2140            self.finish()
2141        }
2142        pub fn kind(mut self) -> String {
2143            self.path.push(ExecutionError::KIND_FIELD.name);
2144            self.finish()
2145        }
2146        pub fn abort(mut self) -> MoveAbortFieldPathBuilder {
2147            self.path.push(ExecutionError::ABORT_FIELD.name);
2148            MoveAbortFieldPathBuilder::new_with_base(self.path)
2149        }
2150        pub fn size_error(mut self) -> SizeErrorFieldPathBuilder {
2151            self.path.push(ExecutionError::SIZE_ERROR_FIELD.name);
2152            SizeErrorFieldPathBuilder::new_with_base(self.path)
2153        }
2154        pub fn command_argument_error(mut self) -> CommandArgumentErrorFieldPathBuilder {
2155            self.path.push(ExecutionError::COMMAND_ARGUMENT_ERROR_FIELD.name);
2156            CommandArgumentErrorFieldPathBuilder::new_with_base(self.path)
2157        }
2158        pub fn type_argument_error(mut self) -> TypeArgumentErrorFieldPathBuilder {
2159            self.path.push(ExecutionError::TYPE_ARGUMENT_ERROR_FIELD.name);
2160            TypeArgumentErrorFieldPathBuilder::new_with_base(self.path)
2161        }
2162        pub fn package_upgrade_error(mut self) -> PackageUpgradeErrorFieldPathBuilder {
2163            self.path.push(ExecutionError::PACKAGE_UPGRADE_ERROR_FIELD.name);
2164            PackageUpgradeErrorFieldPathBuilder::new_with_base(self.path)
2165        }
2166        pub fn index_error(mut self) -> IndexErrorFieldPathBuilder {
2167            self.path.push(ExecutionError::INDEX_ERROR_FIELD.name);
2168            IndexErrorFieldPathBuilder::new_with_base(self.path)
2169        }
2170        pub fn object_id(mut self) -> String {
2171            self.path.push(ExecutionError::OBJECT_ID_FIELD.name);
2172            self.finish()
2173        }
2174        pub fn coin_deny_list_error(mut self) -> CoinDenyListErrorFieldPathBuilder {
2175            self.path.push(ExecutionError::COIN_DENY_LIST_ERROR_FIELD.name);
2176            CoinDenyListErrorFieldPathBuilder::new_with_base(self.path)
2177        }
2178        pub fn congested_objects(mut self) -> CongestedObjectsFieldPathBuilder {
2179            self.path.push(ExecutionError::CONGESTED_OBJECTS_FIELD.name);
2180            CongestedObjectsFieldPathBuilder::new_with_base(self.path)
2181        }
2182    }
2183    impl MoveAbort {
2184        pub const ABORT_CODE_FIELD: &'static MessageField = &MessageField {
2185            name: "abort_code",
2186            json_name: "abortCode",
2187            number: 1i32,
2188            message_fields: None,
2189        };
2190        pub const LOCATION_FIELD: &'static MessageField = &MessageField {
2191            name: "location",
2192            json_name: "location",
2193            number: 2i32,
2194            message_fields: Some(MoveLocation::FIELDS),
2195        };
2196        pub const CLEVER_ERROR_FIELD: &'static MessageField = &MessageField {
2197            name: "clever_error",
2198            json_name: "cleverError",
2199            number: 3i32,
2200            message_fields: Some(CleverError::FIELDS),
2201        };
2202    }
2203    impl MessageFields for MoveAbort {
2204        const FIELDS: &'static [&'static MessageField] = &[
2205            Self::ABORT_CODE_FIELD,
2206            Self::LOCATION_FIELD,
2207            Self::CLEVER_ERROR_FIELD,
2208        ];
2209    }
2210    impl MoveAbort {
2211        pub fn path_builder() -> MoveAbortFieldPathBuilder {
2212            MoveAbortFieldPathBuilder::new()
2213        }
2214    }
2215    pub struct MoveAbortFieldPathBuilder {
2216        path: Vec<&'static str>,
2217    }
2218    impl MoveAbortFieldPathBuilder {
2219        #[allow(clippy::new_without_default)]
2220        pub fn new() -> Self {
2221            Self { path: Default::default() }
2222        }
2223        #[doc(hidden)]
2224        pub fn new_with_base(base: Vec<&'static str>) -> Self {
2225            Self { path: base }
2226        }
2227        pub fn finish(self) -> String {
2228            self.path.join(".")
2229        }
2230        pub fn abort_code(mut self) -> String {
2231            self.path.push(MoveAbort::ABORT_CODE_FIELD.name);
2232            self.finish()
2233        }
2234        pub fn location(mut self) -> MoveLocationFieldPathBuilder {
2235            self.path.push(MoveAbort::LOCATION_FIELD.name);
2236            MoveLocationFieldPathBuilder::new_with_base(self.path)
2237        }
2238        pub fn clever_error(mut self) -> CleverErrorFieldPathBuilder {
2239            self.path.push(MoveAbort::CLEVER_ERROR_FIELD.name);
2240            CleverErrorFieldPathBuilder::new_with_base(self.path)
2241        }
2242    }
2243    impl MoveLocation {
2244        pub const PACKAGE_FIELD: &'static MessageField = &MessageField {
2245            name: "package",
2246            json_name: "package",
2247            number: 1i32,
2248            message_fields: None,
2249        };
2250        pub const MODULE_FIELD: &'static MessageField = &MessageField {
2251            name: "module",
2252            json_name: "module",
2253            number: 2i32,
2254            message_fields: None,
2255        };
2256        pub const FUNCTION_FIELD: &'static MessageField = &MessageField {
2257            name: "function",
2258            json_name: "function",
2259            number: 3i32,
2260            message_fields: None,
2261        };
2262        pub const INSTRUCTION_FIELD: &'static MessageField = &MessageField {
2263            name: "instruction",
2264            json_name: "instruction",
2265            number: 4i32,
2266            message_fields: None,
2267        };
2268        pub const FUNCTION_NAME_FIELD: &'static MessageField = &MessageField {
2269            name: "function_name",
2270            json_name: "functionName",
2271            number: 5i32,
2272            message_fields: None,
2273        };
2274    }
2275    impl MessageFields for MoveLocation {
2276        const FIELDS: &'static [&'static MessageField] = &[
2277            Self::PACKAGE_FIELD,
2278            Self::MODULE_FIELD,
2279            Self::FUNCTION_FIELD,
2280            Self::INSTRUCTION_FIELD,
2281            Self::FUNCTION_NAME_FIELD,
2282        ];
2283    }
2284    impl MoveLocation {
2285        pub fn path_builder() -> MoveLocationFieldPathBuilder {
2286            MoveLocationFieldPathBuilder::new()
2287        }
2288    }
2289    pub struct MoveLocationFieldPathBuilder {
2290        path: Vec<&'static str>,
2291    }
2292    impl MoveLocationFieldPathBuilder {
2293        #[allow(clippy::new_without_default)]
2294        pub fn new() -> Self {
2295            Self { path: Default::default() }
2296        }
2297        #[doc(hidden)]
2298        pub fn new_with_base(base: Vec<&'static str>) -> Self {
2299            Self { path: base }
2300        }
2301        pub fn finish(self) -> String {
2302            self.path.join(".")
2303        }
2304        pub fn package(mut self) -> String {
2305            self.path.push(MoveLocation::PACKAGE_FIELD.name);
2306            self.finish()
2307        }
2308        pub fn module(mut self) -> String {
2309            self.path.push(MoveLocation::MODULE_FIELD.name);
2310            self.finish()
2311        }
2312        pub fn function(mut self) -> String {
2313            self.path.push(MoveLocation::FUNCTION_FIELD.name);
2314            self.finish()
2315        }
2316        pub fn instruction(mut self) -> String {
2317            self.path.push(MoveLocation::INSTRUCTION_FIELD.name);
2318            self.finish()
2319        }
2320        pub fn function_name(mut self) -> String {
2321            self.path.push(MoveLocation::FUNCTION_NAME_FIELD.name);
2322            self.finish()
2323        }
2324    }
2325    impl CleverError {
2326        pub const ERROR_CODE_FIELD: &'static MessageField = &MessageField {
2327            name: "error_code",
2328            json_name: "errorCode",
2329            number: 1i32,
2330            message_fields: None,
2331        };
2332        pub const LINE_NUMBER_FIELD: &'static MessageField = &MessageField {
2333            name: "line_number",
2334            json_name: "lineNumber",
2335            number: 2i32,
2336            message_fields: None,
2337        };
2338        pub const CONSTANT_NAME_FIELD: &'static MessageField = &MessageField {
2339            name: "constant_name",
2340            json_name: "constantName",
2341            number: 3i32,
2342            message_fields: None,
2343        };
2344        pub const CONSTANT_TYPE_FIELD: &'static MessageField = &MessageField {
2345            name: "constant_type",
2346            json_name: "constantType",
2347            number: 4i32,
2348            message_fields: None,
2349        };
2350        pub const RENDERED_FIELD: &'static MessageField = &MessageField {
2351            name: "rendered",
2352            json_name: "rendered",
2353            number: 5i32,
2354            message_fields: None,
2355        };
2356        pub const RAW_FIELD: &'static MessageField = &MessageField {
2357            name: "raw",
2358            json_name: "raw",
2359            number: 6i32,
2360            message_fields: None,
2361        };
2362    }
2363    impl MessageFields for CleverError {
2364        const FIELDS: &'static [&'static MessageField] = &[
2365            Self::ERROR_CODE_FIELD,
2366            Self::LINE_NUMBER_FIELD,
2367            Self::CONSTANT_NAME_FIELD,
2368            Self::CONSTANT_TYPE_FIELD,
2369            Self::RENDERED_FIELD,
2370            Self::RAW_FIELD,
2371        ];
2372    }
2373    impl CleverError {
2374        pub fn path_builder() -> CleverErrorFieldPathBuilder {
2375            CleverErrorFieldPathBuilder::new()
2376        }
2377    }
2378    pub struct CleverErrorFieldPathBuilder {
2379        path: Vec<&'static str>,
2380    }
2381    impl CleverErrorFieldPathBuilder {
2382        #[allow(clippy::new_without_default)]
2383        pub fn new() -> Self {
2384            Self { path: Default::default() }
2385        }
2386        #[doc(hidden)]
2387        pub fn new_with_base(base: Vec<&'static str>) -> Self {
2388            Self { path: base }
2389        }
2390        pub fn finish(self) -> String {
2391            self.path.join(".")
2392        }
2393        pub fn error_code(mut self) -> String {
2394            self.path.push(CleverError::ERROR_CODE_FIELD.name);
2395            self.finish()
2396        }
2397        pub fn line_number(mut self) -> String {
2398            self.path.push(CleverError::LINE_NUMBER_FIELD.name);
2399            self.finish()
2400        }
2401        pub fn constant_name(mut self) -> String {
2402            self.path.push(CleverError::CONSTANT_NAME_FIELD.name);
2403            self.finish()
2404        }
2405        pub fn constant_type(mut self) -> String {
2406            self.path.push(CleverError::CONSTANT_TYPE_FIELD.name);
2407            self.finish()
2408        }
2409        pub fn rendered(mut self) -> String {
2410            self.path.push(CleverError::RENDERED_FIELD.name);
2411            self.finish()
2412        }
2413        pub fn raw(mut self) -> String {
2414            self.path.push(CleverError::RAW_FIELD.name);
2415            self.finish()
2416        }
2417    }
2418    impl SizeError {
2419        pub const SIZE_FIELD: &'static MessageField = &MessageField {
2420            name: "size",
2421            json_name: "size",
2422            number: 1i32,
2423            message_fields: None,
2424        };
2425        pub const MAX_SIZE_FIELD: &'static MessageField = &MessageField {
2426            name: "max_size",
2427            json_name: "maxSize",
2428            number: 2i32,
2429            message_fields: None,
2430        };
2431    }
2432    impl MessageFields for SizeError {
2433        const FIELDS: &'static [&'static MessageField] = &[
2434            Self::SIZE_FIELD,
2435            Self::MAX_SIZE_FIELD,
2436        ];
2437    }
2438    impl SizeError {
2439        pub fn path_builder() -> SizeErrorFieldPathBuilder {
2440            SizeErrorFieldPathBuilder::new()
2441        }
2442    }
2443    pub struct SizeErrorFieldPathBuilder {
2444        path: Vec<&'static str>,
2445    }
2446    impl SizeErrorFieldPathBuilder {
2447        #[allow(clippy::new_without_default)]
2448        pub fn new() -> Self {
2449            Self { path: Default::default() }
2450        }
2451        #[doc(hidden)]
2452        pub fn new_with_base(base: Vec<&'static str>) -> Self {
2453            Self { path: base }
2454        }
2455        pub fn finish(self) -> String {
2456            self.path.join(".")
2457        }
2458        pub fn size(mut self) -> String {
2459            self.path.push(SizeError::SIZE_FIELD.name);
2460            self.finish()
2461        }
2462        pub fn max_size(mut self) -> String {
2463            self.path.push(SizeError::MAX_SIZE_FIELD.name);
2464            self.finish()
2465        }
2466    }
2467    impl IndexError {
2468        pub const INDEX_FIELD: &'static MessageField = &MessageField {
2469            name: "index",
2470            json_name: "index",
2471            number: 1i32,
2472            message_fields: None,
2473        };
2474        pub const SUBRESULT_FIELD: &'static MessageField = &MessageField {
2475            name: "subresult",
2476            json_name: "subresult",
2477            number: 2i32,
2478            message_fields: None,
2479        };
2480    }
2481    impl MessageFields for IndexError {
2482        const FIELDS: &'static [&'static MessageField] = &[
2483            Self::INDEX_FIELD,
2484            Self::SUBRESULT_FIELD,
2485        ];
2486    }
2487    impl IndexError {
2488        pub fn path_builder() -> IndexErrorFieldPathBuilder {
2489            IndexErrorFieldPathBuilder::new()
2490        }
2491    }
2492    pub struct IndexErrorFieldPathBuilder {
2493        path: Vec<&'static str>,
2494    }
2495    impl IndexErrorFieldPathBuilder {
2496        #[allow(clippy::new_without_default)]
2497        pub fn new() -> Self {
2498            Self { path: Default::default() }
2499        }
2500        #[doc(hidden)]
2501        pub fn new_with_base(base: Vec<&'static str>) -> Self {
2502            Self { path: base }
2503        }
2504        pub fn finish(self) -> String {
2505            self.path.join(".")
2506        }
2507        pub fn index(mut self) -> String {
2508            self.path.push(IndexError::INDEX_FIELD.name);
2509            self.finish()
2510        }
2511        pub fn subresult(mut self) -> String {
2512            self.path.push(IndexError::SUBRESULT_FIELD.name);
2513            self.finish()
2514        }
2515    }
2516    impl CoinDenyListError {
2517        pub const ADDRESS_FIELD: &'static MessageField = &MessageField {
2518            name: "address",
2519            json_name: "address",
2520            number: 1i32,
2521            message_fields: None,
2522        };
2523        pub const COIN_TYPE_FIELD: &'static MessageField = &MessageField {
2524            name: "coin_type",
2525            json_name: "coinType",
2526            number: 2i32,
2527            message_fields: None,
2528        };
2529    }
2530    impl MessageFields for CoinDenyListError {
2531        const FIELDS: &'static [&'static MessageField] = &[
2532            Self::ADDRESS_FIELD,
2533            Self::COIN_TYPE_FIELD,
2534        ];
2535    }
2536    impl CoinDenyListError {
2537        pub fn path_builder() -> CoinDenyListErrorFieldPathBuilder {
2538            CoinDenyListErrorFieldPathBuilder::new()
2539        }
2540    }
2541    pub struct CoinDenyListErrorFieldPathBuilder {
2542        path: Vec<&'static str>,
2543    }
2544    impl CoinDenyListErrorFieldPathBuilder {
2545        #[allow(clippy::new_without_default)]
2546        pub fn new() -> Self {
2547            Self { path: Default::default() }
2548        }
2549        #[doc(hidden)]
2550        pub fn new_with_base(base: Vec<&'static str>) -> Self {
2551            Self { path: base }
2552        }
2553        pub fn finish(self) -> String {
2554            self.path.join(".")
2555        }
2556        pub fn address(mut self) -> String {
2557            self.path.push(CoinDenyListError::ADDRESS_FIELD.name);
2558            self.finish()
2559        }
2560        pub fn coin_type(mut self) -> String {
2561            self.path.push(CoinDenyListError::COIN_TYPE_FIELD.name);
2562            self.finish()
2563        }
2564    }
2565    impl CongestedObjects {
2566        pub const OBJECTS_FIELD: &'static MessageField = &MessageField {
2567            name: "objects",
2568            json_name: "objects",
2569            number: 1i32,
2570            message_fields: None,
2571        };
2572    }
2573    impl MessageFields for CongestedObjects {
2574        const FIELDS: &'static [&'static MessageField] = &[Self::OBJECTS_FIELD];
2575    }
2576    impl CongestedObjects {
2577        pub fn path_builder() -> CongestedObjectsFieldPathBuilder {
2578            CongestedObjectsFieldPathBuilder::new()
2579        }
2580    }
2581    pub struct CongestedObjectsFieldPathBuilder {
2582        path: Vec<&'static str>,
2583    }
2584    impl CongestedObjectsFieldPathBuilder {
2585        #[allow(clippy::new_without_default)]
2586        pub fn new() -> Self {
2587            Self { path: Default::default() }
2588        }
2589        #[doc(hidden)]
2590        pub fn new_with_base(base: Vec<&'static str>) -> Self {
2591            Self { path: base }
2592        }
2593        pub fn finish(self) -> String {
2594            self.path.join(".")
2595        }
2596        pub fn objects(mut self) -> String {
2597            self.path.push(CongestedObjects::OBJECTS_FIELD.name);
2598            self.finish()
2599        }
2600    }
2601    impl CommandArgumentError {
2602        pub const ARGUMENT_FIELD: &'static MessageField = &MessageField {
2603            name: "argument",
2604            json_name: "argument",
2605            number: 1i32,
2606            message_fields: None,
2607        };
2608        pub const KIND_FIELD: &'static MessageField = &MessageField {
2609            name: "kind",
2610            json_name: "kind",
2611            number: 2i32,
2612            message_fields: None,
2613        };
2614        pub const INDEX_ERROR_FIELD: &'static MessageField = &MessageField {
2615            name: "index_error",
2616            json_name: "indexError",
2617            number: 3i32,
2618            message_fields: Some(IndexError::FIELDS),
2619        };
2620    }
2621    impl MessageFields for CommandArgumentError {
2622        const FIELDS: &'static [&'static MessageField] = &[
2623            Self::ARGUMENT_FIELD,
2624            Self::KIND_FIELD,
2625            Self::INDEX_ERROR_FIELD,
2626        ];
2627    }
2628    impl CommandArgumentError {
2629        pub fn path_builder() -> CommandArgumentErrorFieldPathBuilder {
2630            CommandArgumentErrorFieldPathBuilder::new()
2631        }
2632    }
2633    pub struct CommandArgumentErrorFieldPathBuilder {
2634        path: Vec<&'static str>,
2635    }
2636    impl CommandArgumentErrorFieldPathBuilder {
2637        #[allow(clippy::new_without_default)]
2638        pub fn new() -> Self {
2639            Self { path: Default::default() }
2640        }
2641        #[doc(hidden)]
2642        pub fn new_with_base(base: Vec<&'static str>) -> Self {
2643            Self { path: base }
2644        }
2645        pub fn finish(self) -> String {
2646            self.path.join(".")
2647        }
2648        pub fn argument(mut self) -> String {
2649            self.path.push(CommandArgumentError::ARGUMENT_FIELD.name);
2650            self.finish()
2651        }
2652        pub fn kind(mut self) -> String {
2653            self.path.push(CommandArgumentError::KIND_FIELD.name);
2654            self.finish()
2655        }
2656        pub fn index_error(mut self) -> IndexErrorFieldPathBuilder {
2657            self.path.push(CommandArgumentError::INDEX_ERROR_FIELD.name);
2658            IndexErrorFieldPathBuilder::new_with_base(self.path)
2659        }
2660    }
2661    impl PackageUpgradeError {
2662        pub const KIND_FIELD: &'static MessageField = &MessageField {
2663            name: "kind",
2664            json_name: "kind",
2665            number: 1i32,
2666            message_fields: None,
2667        };
2668        pub const PACKAGE_ID_FIELD: &'static MessageField = &MessageField {
2669            name: "package_id",
2670            json_name: "packageId",
2671            number: 2i32,
2672            message_fields: None,
2673        };
2674        pub const DIGEST_FIELD: &'static MessageField = &MessageField {
2675            name: "digest",
2676            json_name: "digest",
2677            number: 3i32,
2678            message_fields: None,
2679        };
2680        pub const POLICY_FIELD: &'static MessageField = &MessageField {
2681            name: "policy",
2682            json_name: "policy",
2683            number: 4i32,
2684            message_fields: None,
2685        };
2686        pub const TICKET_ID_FIELD: &'static MessageField = &MessageField {
2687            name: "ticket_id",
2688            json_name: "ticketId",
2689            number: 5i32,
2690            message_fields: None,
2691        };
2692    }
2693    impl MessageFields for PackageUpgradeError {
2694        const FIELDS: &'static [&'static MessageField] = &[
2695            Self::KIND_FIELD,
2696            Self::PACKAGE_ID_FIELD,
2697            Self::DIGEST_FIELD,
2698            Self::POLICY_FIELD,
2699            Self::TICKET_ID_FIELD,
2700        ];
2701    }
2702    impl PackageUpgradeError {
2703        pub fn path_builder() -> PackageUpgradeErrorFieldPathBuilder {
2704            PackageUpgradeErrorFieldPathBuilder::new()
2705        }
2706    }
2707    pub struct PackageUpgradeErrorFieldPathBuilder {
2708        path: Vec<&'static str>,
2709    }
2710    impl PackageUpgradeErrorFieldPathBuilder {
2711        #[allow(clippy::new_without_default)]
2712        pub fn new() -> Self {
2713            Self { path: Default::default() }
2714        }
2715        #[doc(hidden)]
2716        pub fn new_with_base(base: Vec<&'static str>) -> Self {
2717            Self { path: base }
2718        }
2719        pub fn finish(self) -> String {
2720            self.path.join(".")
2721        }
2722        pub fn kind(mut self) -> String {
2723            self.path.push(PackageUpgradeError::KIND_FIELD.name);
2724            self.finish()
2725        }
2726        pub fn package_id(mut self) -> String {
2727            self.path.push(PackageUpgradeError::PACKAGE_ID_FIELD.name);
2728            self.finish()
2729        }
2730        pub fn digest(mut self) -> String {
2731            self.path.push(PackageUpgradeError::DIGEST_FIELD.name);
2732            self.finish()
2733        }
2734        pub fn policy(mut self) -> String {
2735            self.path.push(PackageUpgradeError::POLICY_FIELD.name);
2736            self.finish()
2737        }
2738        pub fn ticket_id(mut self) -> String {
2739            self.path.push(PackageUpgradeError::TICKET_ID_FIELD.name);
2740            self.finish()
2741        }
2742    }
2743    impl TypeArgumentError {
2744        pub const TYPE_ARGUMENT_FIELD: &'static MessageField = &MessageField {
2745            name: "type_argument",
2746            json_name: "typeArgument",
2747            number: 1i32,
2748            message_fields: None,
2749        };
2750        pub const KIND_FIELD: &'static MessageField = &MessageField {
2751            name: "kind",
2752            json_name: "kind",
2753            number: 2i32,
2754            message_fields: None,
2755        };
2756    }
2757    impl MessageFields for TypeArgumentError {
2758        const FIELDS: &'static [&'static MessageField] = &[
2759            Self::TYPE_ARGUMENT_FIELD,
2760            Self::KIND_FIELD,
2761        ];
2762    }
2763    impl TypeArgumentError {
2764        pub fn path_builder() -> TypeArgumentErrorFieldPathBuilder {
2765            TypeArgumentErrorFieldPathBuilder::new()
2766        }
2767    }
2768    pub struct TypeArgumentErrorFieldPathBuilder {
2769        path: Vec<&'static str>,
2770    }
2771    impl TypeArgumentErrorFieldPathBuilder {
2772        #[allow(clippy::new_without_default)]
2773        pub fn new() -> Self {
2774            Self { path: Default::default() }
2775        }
2776        #[doc(hidden)]
2777        pub fn new_with_base(base: Vec<&'static str>) -> Self {
2778            Self { path: base }
2779        }
2780        pub fn finish(self) -> String {
2781            self.path.join(".")
2782        }
2783        pub fn type_argument(mut self) -> String {
2784            self.path.push(TypeArgumentError::TYPE_ARGUMENT_FIELD.name);
2785            self.finish()
2786        }
2787        pub fn kind(mut self) -> String {
2788            self.path.push(TypeArgumentError::KIND_FIELD.name);
2789            self.finish()
2790        }
2791    }
2792    impl TransactionFilter {
2793        pub const TERMS_FIELD: &'static MessageField = &MessageField {
2794            name: "terms",
2795            json_name: "terms",
2796            number: 1i32,
2797            message_fields: Some(TransactionTerm::FIELDS),
2798        };
2799    }
2800    impl MessageFields for TransactionFilter {
2801        const FIELDS: &'static [&'static MessageField] = &[Self::TERMS_FIELD];
2802    }
2803    impl TransactionFilter {
2804        pub fn path_builder() -> TransactionFilterFieldPathBuilder {
2805            TransactionFilterFieldPathBuilder::new()
2806        }
2807    }
2808    pub struct TransactionFilterFieldPathBuilder {
2809        path: Vec<&'static str>,
2810    }
2811    impl TransactionFilterFieldPathBuilder {
2812        #[allow(clippy::new_without_default)]
2813        pub fn new() -> Self {
2814            Self { path: Default::default() }
2815        }
2816        #[doc(hidden)]
2817        pub fn new_with_base(base: Vec<&'static str>) -> Self {
2818            Self { path: base }
2819        }
2820        pub fn finish(self) -> String {
2821            self.path.join(".")
2822        }
2823        pub fn terms(mut self) -> TransactionTermFieldPathBuilder {
2824            self.path.push(TransactionFilter::TERMS_FIELD.name);
2825            TransactionTermFieldPathBuilder::new_with_base(self.path)
2826        }
2827    }
2828    impl TransactionTerm {
2829        pub const LITERALS_FIELD: &'static MessageField = &MessageField {
2830            name: "literals",
2831            json_name: "literals",
2832            number: 1i32,
2833            message_fields: Some(TransactionLiteral::FIELDS),
2834        };
2835    }
2836    impl MessageFields for TransactionTerm {
2837        const FIELDS: &'static [&'static MessageField] = &[Self::LITERALS_FIELD];
2838    }
2839    impl TransactionTerm {
2840        pub fn path_builder() -> TransactionTermFieldPathBuilder {
2841            TransactionTermFieldPathBuilder::new()
2842        }
2843    }
2844    pub struct TransactionTermFieldPathBuilder {
2845        path: Vec<&'static str>,
2846    }
2847    impl TransactionTermFieldPathBuilder {
2848        #[allow(clippy::new_without_default)]
2849        pub fn new() -> Self {
2850            Self { path: Default::default() }
2851        }
2852        #[doc(hidden)]
2853        pub fn new_with_base(base: Vec<&'static str>) -> Self {
2854            Self { path: base }
2855        }
2856        pub fn finish(self) -> String {
2857            self.path.join(".")
2858        }
2859        pub fn literals(mut self) -> TransactionLiteralFieldPathBuilder {
2860            self.path.push(TransactionTerm::LITERALS_FIELD.name);
2861            TransactionLiteralFieldPathBuilder::new_with_base(self.path)
2862        }
2863    }
2864    impl TransactionLiteral {
2865        pub const NEGATED_FIELD: &'static MessageField = &MessageField {
2866            name: "negated",
2867            json_name: "negated",
2868            number: 1i32,
2869            message_fields: None,
2870        };
2871        pub const SENDER_FIELD: &'static MessageField = &MessageField {
2872            name: "sender",
2873            json_name: "sender",
2874            number: 2i32,
2875            message_fields: Some(SenderFilter::FIELDS),
2876        };
2877        pub const AFFECTED_ADDRESS_FIELD: &'static MessageField = &MessageField {
2878            name: "affected_address",
2879            json_name: "affectedAddress",
2880            number: 3i32,
2881            message_fields: Some(AffectedAddressFilter::FIELDS),
2882        };
2883        pub const AFFECTED_OBJECT_FIELD: &'static MessageField = &MessageField {
2884            name: "affected_object",
2885            json_name: "affectedObject",
2886            number: 4i32,
2887            message_fields: Some(AffectedObjectFilter::FIELDS),
2888        };
2889        pub const MOVE_CALL_FIELD: &'static MessageField = &MessageField {
2890            name: "move_call",
2891            json_name: "moveCall",
2892            number: 5i32,
2893            message_fields: Some(MoveCallFilter::FIELDS),
2894        };
2895        pub const EMIT_MODULE_FIELD: &'static MessageField = &MessageField {
2896            name: "emit_module",
2897            json_name: "emitModule",
2898            number: 6i32,
2899            message_fields: Some(EmitModuleFilter::FIELDS),
2900        };
2901        pub const EVENT_TYPE_FIELD: &'static MessageField = &MessageField {
2902            name: "event_type",
2903            json_name: "eventType",
2904            number: 7i32,
2905            message_fields: Some(EventTypeFilter::FIELDS),
2906        };
2907        pub const EVENT_STREAM_HEAD_FIELD: &'static MessageField = &MessageField {
2908            name: "event_stream_head",
2909            json_name: "eventStreamHead",
2910            number: 8i32,
2911            message_fields: Some(EventStreamHeadFilter::FIELDS),
2912        };
2913        pub const PACKAGE_WRITE_FIELD: &'static MessageField = &MessageField {
2914            name: "package_write",
2915            json_name: "packageWrite",
2916            number: 9i32,
2917            message_fields: Some(PackageWriteFilter::FIELDS),
2918        };
2919    }
2920    impl MessageFields for TransactionLiteral {
2921        const FIELDS: &'static [&'static MessageField] = &[
2922            Self::NEGATED_FIELD,
2923            Self::SENDER_FIELD,
2924            Self::AFFECTED_ADDRESS_FIELD,
2925            Self::AFFECTED_OBJECT_FIELD,
2926            Self::MOVE_CALL_FIELD,
2927            Self::EMIT_MODULE_FIELD,
2928            Self::EVENT_TYPE_FIELD,
2929            Self::EVENT_STREAM_HEAD_FIELD,
2930            Self::PACKAGE_WRITE_FIELD,
2931        ];
2932    }
2933    impl TransactionLiteral {
2934        pub fn path_builder() -> TransactionLiteralFieldPathBuilder {
2935            TransactionLiteralFieldPathBuilder::new()
2936        }
2937    }
2938    pub struct TransactionLiteralFieldPathBuilder {
2939        path: Vec<&'static str>,
2940    }
2941    impl TransactionLiteralFieldPathBuilder {
2942        #[allow(clippy::new_without_default)]
2943        pub fn new() -> Self {
2944            Self { path: Default::default() }
2945        }
2946        #[doc(hidden)]
2947        pub fn new_with_base(base: Vec<&'static str>) -> Self {
2948            Self { path: base }
2949        }
2950        pub fn finish(self) -> String {
2951            self.path.join(".")
2952        }
2953        pub fn negated(mut self) -> String {
2954            self.path.push(TransactionLiteral::NEGATED_FIELD.name);
2955            self.finish()
2956        }
2957        pub fn sender(mut self) -> SenderFilterFieldPathBuilder {
2958            self.path.push(TransactionLiteral::SENDER_FIELD.name);
2959            SenderFilterFieldPathBuilder::new_with_base(self.path)
2960        }
2961        pub fn affected_address(mut self) -> AffectedAddressFilterFieldPathBuilder {
2962            self.path.push(TransactionLiteral::AFFECTED_ADDRESS_FIELD.name);
2963            AffectedAddressFilterFieldPathBuilder::new_with_base(self.path)
2964        }
2965        pub fn affected_object(mut self) -> AffectedObjectFilterFieldPathBuilder {
2966            self.path.push(TransactionLiteral::AFFECTED_OBJECT_FIELD.name);
2967            AffectedObjectFilterFieldPathBuilder::new_with_base(self.path)
2968        }
2969        pub fn move_call(mut self) -> MoveCallFilterFieldPathBuilder {
2970            self.path.push(TransactionLiteral::MOVE_CALL_FIELD.name);
2971            MoveCallFilterFieldPathBuilder::new_with_base(self.path)
2972        }
2973        pub fn emit_module(mut self) -> EmitModuleFilterFieldPathBuilder {
2974            self.path.push(TransactionLiteral::EMIT_MODULE_FIELD.name);
2975            EmitModuleFilterFieldPathBuilder::new_with_base(self.path)
2976        }
2977        pub fn event_type(mut self) -> EventTypeFilterFieldPathBuilder {
2978            self.path.push(TransactionLiteral::EVENT_TYPE_FIELD.name);
2979            EventTypeFilterFieldPathBuilder::new_with_base(self.path)
2980        }
2981        pub fn event_stream_head(mut self) -> EventStreamHeadFilterFieldPathBuilder {
2982            self.path.push(TransactionLiteral::EVENT_STREAM_HEAD_FIELD.name);
2983            EventStreamHeadFilterFieldPathBuilder::new_with_base(self.path)
2984        }
2985        pub fn package_write(mut self) -> PackageWriteFilterFieldPathBuilder {
2986            self.path.push(TransactionLiteral::PACKAGE_WRITE_FIELD.name);
2987            PackageWriteFilterFieldPathBuilder::new_with_base(self.path)
2988        }
2989    }
2990    impl EventFilter {
2991        pub const TERMS_FIELD: &'static MessageField = &MessageField {
2992            name: "terms",
2993            json_name: "terms",
2994            number: 1i32,
2995            message_fields: Some(EventTerm::FIELDS),
2996        };
2997    }
2998    impl MessageFields for EventFilter {
2999        const FIELDS: &'static [&'static MessageField] = &[Self::TERMS_FIELD];
3000    }
3001    impl EventFilter {
3002        pub fn path_builder() -> EventFilterFieldPathBuilder {
3003            EventFilterFieldPathBuilder::new()
3004        }
3005    }
3006    pub struct EventFilterFieldPathBuilder {
3007        path: Vec<&'static str>,
3008    }
3009    impl EventFilterFieldPathBuilder {
3010        #[allow(clippy::new_without_default)]
3011        pub fn new() -> Self {
3012            Self { path: Default::default() }
3013        }
3014        #[doc(hidden)]
3015        pub fn new_with_base(base: Vec<&'static str>) -> Self {
3016            Self { path: base }
3017        }
3018        pub fn finish(self) -> String {
3019            self.path.join(".")
3020        }
3021        pub fn terms(mut self) -> EventTermFieldPathBuilder {
3022            self.path.push(EventFilter::TERMS_FIELD.name);
3023            EventTermFieldPathBuilder::new_with_base(self.path)
3024        }
3025    }
3026    impl EventTerm {
3027        pub const LITERALS_FIELD: &'static MessageField = &MessageField {
3028            name: "literals",
3029            json_name: "literals",
3030            number: 1i32,
3031            message_fields: Some(EventLiteral::FIELDS),
3032        };
3033    }
3034    impl MessageFields for EventTerm {
3035        const FIELDS: &'static [&'static MessageField] = &[Self::LITERALS_FIELD];
3036    }
3037    impl EventTerm {
3038        pub fn path_builder() -> EventTermFieldPathBuilder {
3039            EventTermFieldPathBuilder::new()
3040        }
3041    }
3042    pub struct EventTermFieldPathBuilder {
3043        path: Vec<&'static str>,
3044    }
3045    impl EventTermFieldPathBuilder {
3046        #[allow(clippy::new_without_default)]
3047        pub fn new() -> Self {
3048            Self { path: Default::default() }
3049        }
3050        #[doc(hidden)]
3051        pub fn new_with_base(base: Vec<&'static str>) -> Self {
3052            Self { path: base }
3053        }
3054        pub fn finish(self) -> String {
3055            self.path.join(".")
3056        }
3057        pub fn literals(mut self) -> EventLiteralFieldPathBuilder {
3058            self.path.push(EventTerm::LITERALS_FIELD.name);
3059            EventLiteralFieldPathBuilder::new_with_base(self.path)
3060        }
3061    }
3062    impl EventLiteral {
3063        pub const NEGATED_FIELD: &'static MessageField = &MessageField {
3064            name: "negated",
3065            json_name: "negated",
3066            number: 1i32,
3067            message_fields: None,
3068        };
3069        pub const SENDER_FIELD: &'static MessageField = &MessageField {
3070            name: "sender",
3071            json_name: "sender",
3072            number: 2i32,
3073            message_fields: Some(SenderFilter::FIELDS),
3074        };
3075        pub const EMIT_MODULE_FIELD: &'static MessageField = &MessageField {
3076            name: "emit_module",
3077            json_name: "emitModule",
3078            number: 3i32,
3079            message_fields: Some(EmitModuleFilter::FIELDS),
3080        };
3081        pub const EVENT_TYPE_FIELD: &'static MessageField = &MessageField {
3082            name: "event_type",
3083            json_name: "eventType",
3084            number: 4i32,
3085            message_fields: Some(EventTypeFilter::FIELDS),
3086        };
3087        pub const EVENT_STREAM_HEAD_FIELD: &'static MessageField = &MessageField {
3088            name: "event_stream_head",
3089            json_name: "eventStreamHead",
3090            number: 5i32,
3091            message_fields: Some(EventStreamHeadFilter::FIELDS),
3092        };
3093    }
3094    impl MessageFields for EventLiteral {
3095        const FIELDS: &'static [&'static MessageField] = &[
3096            Self::NEGATED_FIELD,
3097            Self::SENDER_FIELD,
3098            Self::EMIT_MODULE_FIELD,
3099            Self::EVENT_TYPE_FIELD,
3100            Self::EVENT_STREAM_HEAD_FIELD,
3101        ];
3102    }
3103    impl EventLiteral {
3104        pub fn path_builder() -> EventLiteralFieldPathBuilder {
3105            EventLiteralFieldPathBuilder::new()
3106        }
3107    }
3108    pub struct EventLiteralFieldPathBuilder {
3109        path: Vec<&'static str>,
3110    }
3111    impl EventLiteralFieldPathBuilder {
3112        #[allow(clippy::new_without_default)]
3113        pub fn new() -> Self {
3114            Self { path: Default::default() }
3115        }
3116        #[doc(hidden)]
3117        pub fn new_with_base(base: Vec<&'static str>) -> Self {
3118            Self { path: base }
3119        }
3120        pub fn finish(self) -> String {
3121            self.path.join(".")
3122        }
3123        pub fn negated(mut self) -> String {
3124            self.path.push(EventLiteral::NEGATED_FIELD.name);
3125            self.finish()
3126        }
3127        pub fn sender(mut self) -> SenderFilterFieldPathBuilder {
3128            self.path.push(EventLiteral::SENDER_FIELD.name);
3129            SenderFilterFieldPathBuilder::new_with_base(self.path)
3130        }
3131        pub fn emit_module(mut self) -> EmitModuleFilterFieldPathBuilder {
3132            self.path.push(EventLiteral::EMIT_MODULE_FIELD.name);
3133            EmitModuleFilterFieldPathBuilder::new_with_base(self.path)
3134        }
3135        pub fn event_type(mut self) -> EventTypeFilterFieldPathBuilder {
3136            self.path.push(EventLiteral::EVENT_TYPE_FIELD.name);
3137            EventTypeFilterFieldPathBuilder::new_with_base(self.path)
3138        }
3139        pub fn event_stream_head(mut self) -> EventStreamHeadFilterFieldPathBuilder {
3140            self.path.push(EventLiteral::EVENT_STREAM_HEAD_FIELD.name);
3141            EventStreamHeadFilterFieldPathBuilder::new_with_base(self.path)
3142        }
3143    }
3144    impl SenderFilter {
3145        pub const ADDRESS_FIELD: &'static MessageField = &MessageField {
3146            name: "address",
3147            json_name: "address",
3148            number: 1i32,
3149            message_fields: None,
3150        };
3151    }
3152    impl MessageFields for SenderFilter {
3153        const FIELDS: &'static [&'static MessageField] = &[Self::ADDRESS_FIELD];
3154    }
3155    impl SenderFilter {
3156        pub fn path_builder() -> SenderFilterFieldPathBuilder {
3157            SenderFilterFieldPathBuilder::new()
3158        }
3159    }
3160    pub struct SenderFilterFieldPathBuilder {
3161        path: Vec<&'static str>,
3162    }
3163    impl SenderFilterFieldPathBuilder {
3164        #[allow(clippy::new_without_default)]
3165        pub fn new() -> Self {
3166            Self { path: Default::default() }
3167        }
3168        #[doc(hidden)]
3169        pub fn new_with_base(base: Vec<&'static str>) -> Self {
3170            Self { path: base }
3171        }
3172        pub fn finish(self) -> String {
3173            self.path.join(".")
3174        }
3175        pub fn address(mut self) -> String {
3176            self.path.push(SenderFilter::ADDRESS_FIELD.name);
3177            self.finish()
3178        }
3179    }
3180    impl AffectedAddressFilter {
3181        pub const ADDRESS_FIELD: &'static MessageField = &MessageField {
3182            name: "address",
3183            json_name: "address",
3184            number: 1i32,
3185            message_fields: None,
3186        };
3187    }
3188    impl MessageFields for AffectedAddressFilter {
3189        const FIELDS: &'static [&'static MessageField] = &[Self::ADDRESS_FIELD];
3190    }
3191    impl AffectedAddressFilter {
3192        pub fn path_builder() -> AffectedAddressFilterFieldPathBuilder {
3193            AffectedAddressFilterFieldPathBuilder::new()
3194        }
3195    }
3196    pub struct AffectedAddressFilterFieldPathBuilder {
3197        path: Vec<&'static str>,
3198    }
3199    impl AffectedAddressFilterFieldPathBuilder {
3200        #[allow(clippy::new_without_default)]
3201        pub fn new() -> Self {
3202            Self { path: Default::default() }
3203        }
3204        #[doc(hidden)]
3205        pub fn new_with_base(base: Vec<&'static str>) -> Self {
3206            Self { path: base }
3207        }
3208        pub fn finish(self) -> String {
3209            self.path.join(".")
3210        }
3211        pub fn address(mut self) -> String {
3212            self.path.push(AffectedAddressFilter::ADDRESS_FIELD.name);
3213            self.finish()
3214        }
3215    }
3216    impl AffectedObjectFilter {
3217        pub const OBJECT_ID_FIELD: &'static MessageField = &MessageField {
3218            name: "object_id",
3219            json_name: "objectId",
3220            number: 1i32,
3221            message_fields: None,
3222        };
3223    }
3224    impl MessageFields for AffectedObjectFilter {
3225        const FIELDS: &'static [&'static MessageField] = &[Self::OBJECT_ID_FIELD];
3226    }
3227    impl AffectedObjectFilter {
3228        pub fn path_builder() -> AffectedObjectFilterFieldPathBuilder {
3229            AffectedObjectFilterFieldPathBuilder::new()
3230        }
3231    }
3232    pub struct AffectedObjectFilterFieldPathBuilder {
3233        path: Vec<&'static str>,
3234    }
3235    impl AffectedObjectFilterFieldPathBuilder {
3236        #[allow(clippy::new_without_default)]
3237        pub fn new() -> Self {
3238            Self { path: Default::default() }
3239        }
3240        #[doc(hidden)]
3241        pub fn new_with_base(base: Vec<&'static str>) -> Self {
3242            Self { path: base }
3243        }
3244        pub fn finish(self) -> String {
3245            self.path.join(".")
3246        }
3247        pub fn object_id(mut self) -> String {
3248            self.path.push(AffectedObjectFilter::OBJECT_ID_FIELD.name);
3249            self.finish()
3250        }
3251    }
3252    impl MoveCallFilter {
3253        pub const FUNCTION_FIELD: &'static MessageField = &MessageField {
3254            name: "function",
3255            json_name: "function",
3256            number: 1i32,
3257            message_fields: None,
3258        };
3259    }
3260    impl MessageFields for MoveCallFilter {
3261        const FIELDS: &'static [&'static MessageField] = &[Self::FUNCTION_FIELD];
3262    }
3263    impl MoveCallFilter {
3264        pub fn path_builder() -> MoveCallFilterFieldPathBuilder {
3265            MoveCallFilterFieldPathBuilder::new()
3266        }
3267    }
3268    pub struct MoveCallFilterFieldPathBuilder {
3269        path: Vec<&'static str>,
3270    }
3271    impl MoveCallFilterFieldPathBuilder {
3272        #[allow(clippy::new_without_default)]
3273        pub fn new() -> Self {
3274            Self { path: Default::default() }
3275        }
3276        #[doc(hidden)]
3277        pub fn new_with_base(base: Vec<&'static str>) -> Self {
3278            Self { path: base }
3279        }
3280        pub fn finish(self) -> String {
3281            self.path.join(".")
3282        }
3283        pub fn function(mut self) -> String {
3284            self.path.push(MoveCallFilter::FUNCTION_FIELD.name);
3285            self.finish()
3286        }
3287    }
3288    impl EmitModuleFilter {
3289        pub const MODULE_FIELD: &'static MessageField = &MessageField {
3290            name: "module",
3291            json_name: "module",
3292            number: 1i32,
3293            message_fields: None,
3294        };
3295    }
3296    impl MessageFields for EmitModuleFilter {
3297        const FIELDS: &'static [&'static MessageField] = &[Self::MODULE_FIELD];
3298    }
3299    impl EmitModuleFilter {
3300        pub fn path_builder() -> EmitModuleFilterFieldPathBuilder {
3301            EmitModuleFilterFieldPathBuilder::new()
3302        }
3303    }
3304    pub struct EmitModuleFilterFieldPathBuilder {
3305        path: Vec<&'static str>,
3306    }
3307    impl EmitModuleFilterFieldPathBuilder {
3308        #[allow(clippy::new_without_default)]
3309        pub fn new() -> Self {
3310            Self { path: Default::default() }
3311        }
3312        #[doc(hidden)]
3313        pub fn new_with_base(base: Vec<&'static str>) -> Self {
3314            Self { path: base }
3315        }
3316        pub fn finish(self) -> String {
3317            self.path.join(".")
3318        }
3319        pub fn module(mut self) -> String {
3320            self.path.push(EmitModuleFilter::MODULE_FIELD.name);
3321            self.finish()
3322        }
3323    }
3324    impl EventTypeFilter {
3325        pub const EVENT_TYPE_FIELD: &'static MessageField = &MessageField {
3326            name: "event_type",
3327            json_name: "eventType",
3328            number: 1i32,
3329            message_fields: None,
3330        };
3331    }
3332    impl MessageFields for EventTypeFilter {
3333        const FIELDS: &'static [&'static MessageField] = &[Self::EVENT_TYPE_FIELD];
3334    }
3335    impl EventTypeFilter {
3336        pub fn path_builder() -> EventTypeFilterFieldPathBuilder {
3337            EventTypeFilterFieldPathBuilder::new()
3338        }
3339    }
3340    pub struct EventTypeFilterFieldPathBuilder {
3341        path: Vec<&'static str>,
3342    }
3343    impl EventTypeFilterFieldPathBuilder {
3344        #[allow(clippy::new_without_default)]
3345        pub fn new() -> Self {
3346            Self { path: Default::default() }
3347        }
3348        #[doc(hidden)]
3349        pub fn new_with_base(base: Vec<&'static str>) -> Self {
3350            Self { path: base }
3351        }
3352        pub fn finish(self) -> String {
3353            self.path.join(".")
3354        }
3355        pub fn event_type(mut self) -> String {
3356            self.path.push(EventTypeFilter::EVENT_TYPE_FIELD.name);
3357            self.finish()
3358        }
3359    }
3360    impl EventStreamHeadFilter {
3361        pub const STREAM_ID_FIELD: &'static MessageField = &MessageField {
3362            name: "stream_id",
3363            json_name: "streamId",
3364            number: 1i32,
3365            message_fields: None,
3366        };
3367    }
3368    impl MessageFields for EventStreamHeadFilter {
3369        const FIELDS: &'static [&'static MessageField] = &[Self::STREAM_ID_FIELD];
3370    }
3371    impl EventStreamHeadFilter {
3372        pub fn path_builder() -> EventStreamHeadFilterFieldPathBuilder {
3373            EventStreamHeadFilterFieldPathBuilder::new()
3374        }
3375    }
3376    pub struct EventStreamHeadFilterFieldPathBuilder {
3377        path: Vec<&'static str>,
3378    }
3379    impl EventStreamHeadFilterFieldPathBuilder {
3380        #[allow(clippy::new_without_default)]
3381        pub fn new() -> Self {
3382            Self { path: Default::default() }
3383        }
3384        #[doc(hidden)]
3385        pub fn new_with_base(base: Vec<&'static str>) -> Self {
3386            Self { path: base }
3387        }
3388        pub fn finish(self) -> String {
3389            self.path.join(".")
3390        }
3391        pub fn stream_id(mut self) -> String {
3392            self.path.push(EventStreamHeadFilter::STREAM_ID_FIELD.name);
3393            self.finish()
3394        }
3395    }
3396    impl PackageWriteFilter {}
3397    impl MessageFields for PackageWriteFilter {
3398        const FIELDS: &'static [&'static MessageField] = &[];
3399    }
3400    impl PackageWriteFilter {
3401        pub fn path_builder() -> PackageWriteFilterFieldPathBuilder {
3402            PackageWriteFilterFieldPathBuilder::new()
3403        }
3404    }
3405    pub struct PackageWriteFilterFieldPathBuilder {
3406        path: Vec<&'static str>,
3407    }
3408    impl PackageWriteFilterFieldPathBuilder {
3409        #[allow(clippy::new_without_default)]
3410        pub fn new() -> Self {
3411            Self { path: Default::default() }
3412        }
3413        #[doc(hidden)]
3414        pub fn new_with_base(base: Vec<&'static str>) -> Self {
3415            Self { path: base }
3416        }
3417        pub fn finish(self) -> String {
3418            self.path.join(".")
3419        }
3420    }
3421    impl GasCostSummary {
3422        pub const COMPUTATION_COST_FIELD: &'static MessageField = &MessageField {
3423            name: "computation_cost",
3424            json_name: "computationCost",
3425            number: 1i32,
3426            message_fields: None,
3427        };
3428        pub const STORAGE_COST_FIELD: &'static MessageField = &MessageField {
3429            name: "storage_cost",
3430            json_name: "storageCost",
3431            number: 2i32,
3432            message_fields: None,
3433        };
3434        pub const STORAGE_REBATE_FIELD: &'static MessageField = &MessageField {
3435            name: "storage_rebate",
3436            json_name: "storageRebate",
3437            number: 3i32,
3438            message_fields: None,
3439        };
3440        pub const NON_REFUNDABLE_STORAGE_FEE_FIELD: &'static MessageField = &MessageField {
3441            name: "non_refundable_storage_fee",
3442            json_name: "nonRefundableStorageFee",
3443            number: 4i32,
3444            message_fields: None,
3445        };
3446    }
3447    impl MessageFields for GasCostSummary {
3448        const FIELDS: &'static [&'static MessageField] = &[
3449            Self::COMPUTATION_COST_FIELD,
3450            Self::STORAGE_COST_FIELD,
3451            Self::STORAGE_REBATE_FIELD,
3452            Self::NON_REFUNDABLE_STORAGE_FEE_FIELD,
3453        ];
3454    }
3455    impl GasCostSummary {
3456        pub fn path_builder() -> GasCostSummaryFieldPathBuilder {
3457            GasCostSummaryFieldPathBuilder::new()
3458        }
3459    }
3460    pub struct GasCostSummaryFieldPathBuilder {
3461        path: Vec<&'static str>,
3462    }
3463    impl GasCostSummaryFieldPathBuilder {
3464        #[allow(clippy::new_without_default)]
3465        pub fn new() -> Self {
3466            Self { path: Default::default() }
3467        }
3468        #[doc(hidden)]
3469        pub fn new_with_base(base: Vec<&'static str>) -> Self {
3470            Self { path: base }
3471        }
3472        pub fn finish(self) -> String {
3473            self.path.join(".")
3474        }
3475        pub fn computation_cost(mut self) -> String {
3476            self.path.push(GasCostSummary::COMPUTATION_COST_FIELD.name);
3477            self.finish()
3478        }
3479        pub fn storage_cost(mut self) -> String {
3480            self.path.push(GasCostSummary::STORAGE_COST_FIELD.name);
3481            self.finish()
3482        }
3483        pub fn storage_rebate(mut self) -> String {
3484            self.path.push(GasCostSummary::STORAGE_REBATE_FIELD.name);
3485            self.finish()
3486        }
3487        pub fn non_refundable_storage_fee(mut self) -> String {
3488            self.path.push(GasCostSummary::NON_REFUNDABLE_STORAGE_FEE_FIELD.name);
3489            self.finish()
3490        }
3491    }
3492    impl Input {
3493        pub const KIND_FIELD: &'static MessageField = &MessageField {
3494            name: "kind",
3495            json_name: "kind",
3496            number: 1i32,
3497            message_fields: None,
3498        };
3499        pub const PURE_FIELD: &'static MessageField = &MessageField {
3500            name: "pure",
3501            json_name: "pure",
3502            number: 2i32,
3503            message_fields: None,
3504        };
3505        pub const OBJECT_ID_FIELD: &'static MessageField = &MessageField {
3506            name: "object_id",
3507            json_name: "objectId",
3508            number: 3i32,
3509            message_fields: None,
3510        };
3511        pub const VERSION_FIELD: &'static MessageField = &MessageField {
3512            name: "version",
3513            json_name: "version",
3514            number: 4i32,
3515            message_fields: None,
3516        };
3517        pub const DIGEST_FIELD: &'static MessageField = &MessageField {
3518            name: "digest",
3519            json_name: "digest",
3520            number: 5i32,
3521            message_fields: None,
3522        };
3523        pub const MUTABLE_FIELD: &'static MessageField = &MessageField {
3524            name: "mutable",
3525            json_name: "mutable",
3526            number: 6i32,
3527            message_fields: None,
3528        };
3529        pub const MUTABILITY_FIELD: &'static MessageField = &MessageField {
3530            name: "mutability",
3531            json_name: "mutability",
3532            number: 7i32,
3533            message_fields: None,
3534        };
3535        pub const FUNDS_WITHDRAWAL_FIELD: &'static MessageField = &MessageField {
3536            name: "funds_withdrawal",
3537            json_name: "fundsWithdrawal",
3538            number: 8i32,
3539            message_fields: Some(FundsWithdrawal::FIELDS),
3540        };
3541        pub const LITERAL_FIELD: &'static MessageField = &MessageField {
3542            name: "literal",
3543            json_name: "literal",
3544            number: 1000i32,
3545            message_fields: None,
3546        };
3547    }
3548    impl MessageFields for Input {
3549        const FIELDS: &'static [&'static MessageField] = &[
3550            Self::KIND_FIELD,
3551            Self::PURE_FIELD,
3552            Self::OBJECT_ID_FIELD,
3553            Self::VERSION_FIELD,
3554            Self::DIGEST_FIELD,
3555            Self::MUTABLE_FIELD,
3556            Self::MUTABILITY_FIELD,
3557            Self::FUNDS_WITHDRAWAL_FIELD,
3558            Self::LITERAL_FIELD,
3559        ];
3560    }
3561    impl Input {
3562        pub fn path_builder() -> InputFieldPathBuilder {
3563            InputFieldPathBuilder::new()
3564        }
3565    }
3566    pub struct InputFieldPathBuilder {
3567        path: Vec<&'static str>,
3568    }
3569    impl InputFieldPathBuilder {
3570        #[allow(clippy::new_without_default)]
3571        pub fn new() -> Self {
3572            Self { path: Default::default() }
3573        }
3574        #[doc(hidden)]
3575        pub fn new_with_base(base: Vec<&'static str>) -> Self {
3576            Self { path: base }
3577        }
3578        pub fn finish(self) -> String {
3579            self.path.join(".")
3580        }
3581        pub fn kind(mut self) -> String {
3582            self.path.push(Input::KIND_FIELD.name);
3583            self.finish()
3584        }
3585        pub fn pure(mut self) -> String {
3586            self.path.push(Input::PURE_FIELD.name);
3587            self.finish()
3588        }
3589        pub fn object_id(mut self) -> String {
3590            self.path.push(Input::OBJECT_ID_FIELD.name);
3591            self.finish()
3592        }
3593        pub fn version(mut self) -> String {
3594            self.path.push(Input::VERSION_FIELD.name);
3595            self.finish()
3596        }
3597        pub fn digest(mut self) -> String {
3598            self.path.push(Input::DIGEST_FIELD.name);
3599            self.finish()
3600        }
3601        pub fn mutable(mut self) -> String {
3602            self.path.push(Input::MUTABLE_FIELD.name);
3603            self.finish()
3604        }
3605        pub fn mutability(mut self) -> String {
3606            self.path.push(Input::MUTABILITY_FIELD.name);
3607            self.finish()
3608        }
3609        pub fn funds_withdrawal(mut self) -> FundsWithdrawalFieldPathBuilder {
3610            self.path.push(Input::FUNDS_WITHDRAWAL_FIELD.name);
3611            FundsWithdrawalFieldPathBuilder::new_with_base(self.path)
3612        }
3613        pub fn literal(mut self) -> String {
3614            self.path.push(Input::LITERAL_FIELD.name);
3615            self.finish()
3616        }
3617    }
3618    impl FundsWithdrawal {
3619        pub const AMOUNT_FIELD: &'static MessageField = &MessageField {
3620            name: "amount",
3621            json_name: "amount",
3622            number: 1i32,
3623            message_fields: None,
3624        };
3625        pub const COIN_TYPE_FIELD: &'static MessageField = &MessageField {
3626            name: "coin_type",
3627            json_name: "coinType",
3628            number: 2i32,
3629            message_fields: None,
3630        };
3631        pub const SOURCE_FIELD: &'static MessageField = &MessageField {
3632            name: "source",
3633            json_name: "source",
3634            number: 3i32,
3635            message_fields: None,
3636        };
3637        pub const FUNDER_FIELD: &'static MessageField = &MessageField {
3638            name: "funder",
3639            json_name: "funder",
3640            number: 4i32,
3641            message_fields: None,
3642        };
3643        pub const ALLOWANCE_FIELD: &'static MessageField = &MessageField {
3644            name: "allowance",
3645            json_name: "allowance",
3646            number: 5i32,
3647            message_fields: None,
3648        };
3649        pub const SEIZED_FROM_FIELD: &'static MessageField = &MessageField {
3650            name: "seized_from",
3651            json_name: "seizedFrom",
3652            number: 6i32,
3653            message_fields: None,
3654        };
3655        pub const SEIZE_AUTH_FIELD: &'static MessageField = &MessageField {
3656            name: "seize_auth",
3657            json_name: "seizeAuth",
3658            number: 7i32,
3659            message_fields: None,
3660        };
3661    }
3662    impl MessageFields for FundsWithdrawal {
3663        const FIELDS: &'static [&'static MessageField] = &[
3664            Self::AMOUNT_FIELD,
3665            Self::COIN_TYPE_FIELD,
3666            Self::SOURCE_FIELD,
3667            Self::FUNDER_FIELD,
3668            Self::ALLOWANCE_FIELD,
3669            Self::SEIZED_FROM_FIELD,
3670            Self::SEIZE_AUTH_FIELD,
3671        ];
3672    }
3673    impl FundsWithdrawal {
3674        pub fn path_builder() -> FundsWithdrawalFieldPathBuilder {
3675            FundsWithdrawalFieldPathBuilder::new()
3676        }
3677    }
3678    pub struct FundsWithdrawalFieldPathBuilder {
3679        path: Vec<&'static str>,
3680    }
3681    impl FundsWithdrawalFieldPathBuilder {
3682        #[allow(clippy::new_without_default)]
3683        pub fn new() -> Self {
3684            Self { path: Default::default() }
3685        }
3686        #[doc(hidden)]
3687        pub fn new_with_base(base: Vec<&'static str>) -> Self {
3688            Self { path: base }
3689        }
3690        pub fn finish(self) -> String {
3691            self.path.join(".")
3692        }
3693        pub fn amount(mut self) -> String {
3694            self.path.push(FundsWithdrawal::AMOUNT_FIELD.name);
3695            self.finish()
3696        }
3697        pub fn coin_type(mut self) -> String {
3698            self.path.push(FundsWithdrawal::COIN_TYPE_FIELD.name);
3699            self.finish()
3700        }
3701        pub fn source(mut self) -> String {
3702            self.path.push(FundsWithdrawal::SOURCE_FIELD.name);
3703            self.finish()
3704        }
3705        pub fn funder(mut self) -> String {
3706            self.path.push(FundsWithdrawal::FUNDER_FIELD.name);
3707            self.finish()
3708        }
3709        pub fn allowance(mut self) -> String {
3710            self.path.push(FundsWithdrawal::ALLOWANCE_FIELD.name);
3711            self.finish()
3712        }
3713        pub fn seized_from(mut self) -> String {
3714            self.path.push(FundsWithdrawal::SEIZED_FROM_FIELD.name);
3715            self.finish()
3716        }
3717        pub fn seize_auth(mut self) -> String {
3718            self.path.push(FundsWithdrawal::SEIZE_AUTH_FIELD.name);
3719            self.finish()
3720        }
3721    }
3722    impl JwkId {
3723        pub const ISS_FIELD: &'static MessageField = &MessageField {
3724            name: "iss",
3725            json_name: "iss",
3726            number: 1i32,
3727            message_fields: None,
3728        };
3729        pub const KID_FIELD: &'static MessageField = &MessageField {
3730            name: "kid",
3731            json_name: "kid",
3732            number: 2i32,
3733            message_fields: None,
3734        };
3735    }
3736    impl MessageFields for JwkId {
3737        const FIELDS: &'static [&'static MessageField] = &[
3738            Self::ISS_FIELD,
3739            Self::KID_FIELD,
3740        ];
3741    }
3742    impl JwkId {
3743        pub fn path_builder() -> JwkIdFieldPathBuilder {
3744            JwkIdFieldPathBuilder::new()
3745        }
3746    }
3747    pub struct JwkIdFieldPathBuilder {
3748        path: Vec<&'static str>,
3749    }
3750    impl JwkIdFieldPathBuilder {
3751        #[allow(clippy::new_without_default)]
3752        pub fn new() -> Self {
3753            Self { path: Default::default() }
3754        }
3755        #[doc(hidden)]
3756        pub fn new_with_base(base: Vec<&'static str>) -> Self {
3757            Self { path: base }
3758        }
3759        pub fn finish(self) -> String {
3760            self.path.join(".")
3761        }
3762        pub fn iss(mut self) -> String {
3763            self.path.push(JwkId::ISS_FIELD.name);
3764            self.finish()
3765        }
3766        pub fn kid(mut self) -> String {
3767            self.path.push(JwkId::KID_FIELD.name);
3768            self.finish()
3769        }
3770    }
3771    impl Jwk {
3772        pub const KTY_FIELD: &'static MessageField = &MessageField {
3773            name: "kty",
3774            json_name: "kty",
3775            number: 1i32,
3776            message_fields: None,
3777        };
3778        pub const E_FIELD: &'static MessageField = &MessageField {
3779            name: "e",
3780            json_name: "e",
3781            number: 2i32,
3782            message_fields: None,
3783        };
3784        pub const N_FIELD: &'static MessageField = &MessageField {
3785            name: "n",
3786            json_name: "n",
3787            number: 3i32,
3788            message_fields: None,
3789        };
3790        pub const ALG_FIELD: &'static MessageField = &MessageField {
3791            name: "alg",
3792            json_name: "alg",
3793            number: 4i32,
3794            message_fields: None,
3795        };
3796    }
3797    impl MessageFields for Jwk {
3798        const FIELDS: &'static [&'static MessageField] = &[
3799            Self::KTY_FIELD,
3800            Self::E_FIELD,
3801            Self::N_FIELD,
3802            Self::ALG_FIELD,
3803        ];
3804    }
3805    impl Jwk {
3806        pub fn path_builder() -> JwkFieldPathBuilder {
3807            JwkFieldPathBuilder::new()
3808        }
3809    }
3810    pub struct JwkFieldPathBuilder {
3811        path: Vec<&'static str>,
3812    }
3813    impl JwkFieldPathBuilder {
3814        #[allow(clippy::new_without_default)]
3815        pub fn new() -> Self {
3816            Self { path: Default::default() }
3817        }
3818        #[doc(hidden)]
3819        pub fn new_with_base(base: Vec<&'static str>) -> Self {
3820            Self { path: base }
3821        }
3822        pub fn finish(self) -> String {
3823            self.path.join(".")
3824        }
3825        pub fn kty(mut self) -> String {
3826            self.path.push(Jwk::KTY_FIELD.name);
3827            self.finish()
3828        }
3829        pub fn e(mut self) -> String {
3830            self.path.push(Jwk::E_FIELD.name);
3831            self.finish()
3832        }
3833        pub fn n(mut self) -> String {
3834            self.path.push(Jwk::N_FIELD.name);
3835            self.finish()
3836        }
3837        pub fn alg(mut self) -> String {
3838            self.path.push(Jwk::ALG_FIELD.name);
3839            self.finish()
3840        }
3841    }
3842    impl GetServiceInfoRequest {}
3843    impl MessageFields for GetServiceInfoRequest {
3844        const FIELDS: &'static [&'static MessageField] = &[];
3845    }
3846    impl GetServiceInfoRequest {
3847        pub fn path_builder() -> GetServiceInfoRequestFieldPathBuilder {
3848            GetServiceInfoRequestFieldPathBuilder::new()
3849        }
3850    }
3851    pub struct GetServiceInfoRequestFieldPathBuilder {
3852        path: Vec<&'static str>,
3853    }
3854    impl GetServiceInfoRequestFieldPathBuilder {
3855        #[allow(clippy::new_without_default)]
3856        pub fn new() -> Self {
3857            Self { path: Default::default() }
3858        }
3859        #[doc(hidden)]
3860        pub fn new_with_base(base: Vec<&'static str>) -> Self {
3861            Self { path: base }
3862        }
3863        pub fn finish(self) -> String {
3864            self.path.join(".")
3865        }
3866    }
3867    impl GetServiceInfoResponse {
3868        pub const CHAIN_ID_FIELD: &'static MessageField = &MessageField {
3869            name: "chain_id",
3870            json_name: "chainId",
3871            number: 1i32,
3872            message_fields: None,
3873        };
3874        pub const CHAIN_FIELD: &'static MessageField = &MessageField {
3875            name: "chain",
3876            json_name: "chain",
3877            number: 2i32,
3878            message_fields: None,
3879        };
3880        pub const EPOCH_FIELD: &'static MessageField = &MessageField {
3881            name: "epoch",
3882            json_name: "epoch",
3883            number: 3i32,
3884            message_fields: None,
3885        };
3886        pub const CHECKPOINT_HEIGHT_FIELD: &'static MessageField = &MessageField {
3887            name: "checkpoint_height",
3888            json_name: "checkpointHeight",
3889            number: 4i32,
3890            message_fields: None,
3891        };
3892        pub const TIMESTAMP_FIELD: &'static MessageField = &MessageField {
3893            name: "timestamp",
3894            json_name: "timestamp",
3895            number: 5i32,
3896            message_fields: None,
3897        };
3898        pub const LOWEST_AVAILABLE_CHECKPOINT_FIELD: &'static MessageField = &MessageField {
3899            name: "lowest_available_checkpoint",
3900            json_name: "lowestAvailableCheckpoint",
3901            number: 6i32,
3902            message_fields: None,
3903        };
3904        pub const LOWEST_AVAILABLE_CHECKPOINT_OBJECTS_FIELD: &'static MessageField = &MessageField {
3905            name: "lowest_available_checkpoint_objects",
3906            json_name: "lowestAvailableCheckpointObjects",
3907            number: 7i32,
3908            message_fields: None,
3909        };
3910        pub const SERVER_FIELD: &'static MessageField = &MessageField {
3911            name: "server",
3912            json_name: "server",
3913            number: 8i32,
3914            message_fields: None,
3915        };
3916    }
3917    impl MessageFields for GetServiceInfoResponse {
3918        const FIELDS: &'static [&'static MessageField] = &[
3919            Self::CHAIN_ID_FIELD,
3920            Self::CHAIN_FIELD,
3921            Self::EPOCH_FIELD,
3922            Self::CHECKPOINT_HEIGHT_FIELD,
3923            Self::TIMESTAMP_FIELD,
3924            Self::LOWEST_AVAILABLE_CHECKPOINT_FIELD,
3925            Self::LOWEST_AVAILABLE_CHECKPOINT_OBJECTS_FIELD,
3926            Self::SERVER_FIELD,
3927        ];
3928    }
3929    impl GetServiceInfoResponse {
3930        pub fn path_builder() -> GetServiceInfoResponseFieldPathBuilder {
3931            GetServiceInfoResponseFieldPathBuilder::new()
3932        }
3933    }
3934    pub struct GetServiceInfoResponseFieldPathBuilder {
3935        path: Vec<&'static str>,
3936    }
3937    impl GetServiceInfoResponseFieldPathBuilder {
3938        #[allow(clippy::new_without_default)]
3939        pub fn new() -> Self {
3940            Self { path: Default::default() }
3941        }
3942        #[doc(hidden)]
3943        pub fn new_with_base(base: Vec<&'static str>) -> Self {
3944            Self { path: base }
3945        }
3946        pub fn finish(self) -> String {
3947            self.path.join(".")
3948        }
3949        pub fn chain_id(mut self) -> String {
3950            self.path.push(GetServiceInfoResponse::CHAIN_ID_FIELD.name);
3951            self.finish()
3952        }
3953        pub fn chain(mut self) -> String {
3954            self.path.push(GetServiceInfoResponse::CHAIN_FIELD.name);
3955            self.finish()
3956        }
3957        pub fn epoch(mut self) -> String {
3958            self.path.push(GetServiceInfoResponse::EPOCH_FIELD.name);
3959            self.finish()
3960        }
3961        pub fn checkpoint_height(mut self) -> String {
3962            self.path.push(GetServiceInfoResponse::CHECKPOINT_HEIGHT_FIELD.name);
3963            self.finish()
3964        }
3965        pub fn timestamp(mut self) -> String {
3966            self.path.push(GetServiceInfoResponse::TIMESTAMP_FIELD.name);
3967            self.finish()
3968        }
3969        pub fn lowest_available_checkpoint(mut self) -> String {
3970            self.path
3971                .push(GetServiceInfoResponse::LOWEST_AVAILABLE_CHECKPOINT_FIELD.name);
3972            self.finish()
3973        }
3974        pub fn lowest_available_checkpoint_objects(mut self) -> String {
3975            self.path
3976                .push(
3977                    GetServiceInfoResponse::LOWEST_AVAILABLE_CHECKPOINT_OBJECTS_FIELD
3978                        .name,
3979                );
3980            self.finish()
3981        }
3982        pub fn server(mut self) -> String {
3983            self.path.push(GetServiceInfoResponse::SERVER_FIELD.name);
3984            self.finish()
3985        }
3986    }
3987    impl GetObjectRequest {
3988        pub const OBJECT_ID_FIELD: &'static MessageField = &MessageField {
3989            name: "object_id",
3990            json_name: "objectId",
3991            number: 1i32,
3992            message_fields: None,
3993        };
3994        pub const VERSION_FIELD: &'static MessageField = &MessageField {
3995            name: "version",
3996            json_name: "version",
3997            number: 2i32,
3998            message_fields: None,
3999        };
4000        pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
4001            name: "read_mask",
4002            json_name: "readMask",
4003            number: 3i32,
4004            message_fields: None,
4005        };
4006        pub const AT_CHECKPOINT_FIELD: &'static MessageField = &MessageField {
4007            name: "at_checkpoint",
4008            json_name: "atCheckpoint",
4009            number: 4i32,
4010            message_fields: None,
4011        };
4012        pub const MAX_VERSION_FIELD: &'static MessageField = &MessageField {
4013            name: "max_version",
4014            json_name: "maxVersion",
4015            number: 5i32,
4016            message_fields: None,
4017        };
4018    }
4019    impl MessageFields for GetObjectRequest {
4020        const FIELDS: &'static [&'static MessageField] = &[
4021            Self::OBJECT_ID_FIELD,
4022            Self::VERSION_FIELD,
4023            Self::READ_MASK_FIELD,
4024            Self::AT_CHECKPOINT_FIELD,
4025            Self::MAX_VERSION_FIELD,
4026        ];
4027    }
4028    impl GetObjectRequest {
4029        pub fn path_builder() -> GetObjectRequestFieldPathBuilder {
4030            GetObjectRequestFieldPathBuilder::new()
4031        }
4032    }
4033    pub struct GetObjectRequestFieldPathBuilder {
4034        path: Vec<&'static str>,
4035    }
4036    impl GetObjectRequestFieldPathBuilder {
4037        #[allow(clippy::new_without_default)]
4038        pub fn new() -> Self {
4039            Self { path: Default::default() }
4040        }
4041        #[doc(hidden)]
4042        pub fn new_with_base(base: Vec<&'static str>) -> Self {
4043            Self { path: base }
4044        }
4045        pub fn finish(self) -> String {
4046            self.path.join(".")
4047        }
4048        pub fn object_id(mut self) -> String {
4049            self.path.push(GetObjectRequest::OBJECT_ID_FIELD.name);
4050            self.finish()
4051        }
4052        pub fn version(mut self) -> String {
4053            self.path.push(GetObjectRequest::VERSION_FIELD.name);
4054            self.finish()
4055        }
4056        pub fn read_mask(mut self) -> String {
4057            self.path.push(GetObjectRequest::READ_MASK_FIELD.name);
4058            self.finish()
4059        }
4060        pub fn at_checkpoint(mut self) -> String {
4061            self.path.push(GetObjectRequest::AT_CHECKPOINT_FIELD.name);
4062            self.finish()
4063        }
4064        pub fn max_version(mut self) -> String {
4065            self.path.push(GetObjectRequest::MAX_VERSION_FIELD.name);
4066            self.finish()
4067        }
4068    }
4069    impl GetObjectResponse {
4070        pub const OBJECT_FIELD: &'static MessageField = &MessageField {
4071            name: "object",
4072            json_name: "object",
4073            number: 1i32,
4074            message_fields: Some(Object::FIELDS),
4075        };
4076    }
4077    impl MessageFields for GetObjectResponse {
4078        const FIELDS: &'static [&'static MessageField] = &[Self::OBJECT_FIELD];
4079    }
4080    impl GetObjectResponse {
4081        pub fn path_builder() -> GetObjectResponseFieldPathBuilder {
4082            GetObjectResponseFieldPathBuilder::new()
4083        }
4084    }
4085    pub struct GetObjectResponseFieldPathBuilder {
4086        path: Vec<&'static str>,
4087    }
4088    impl GetObjectResponseFieldPathBuilder {
4089        #[allow(clippy::new_without_default)]
4090        pub fn new() -> Self {
4091            Self { path: Default::default() }
4092        }
4093        #[doc(hidden)]
4094        pub fn new_with_base(base: Vec<&'static str>) -> Self {
4095            Self { path: base }
4096        }
4097        pub fn finish(self) -> String {
4098            self.path.join(".")
4099        }
4100        pub fn object(mut self) -> ObjectFieldPathBuilder {
4101            self.path.push(GetObjectResponse::OBJECT_FIELD.name);
4102            ObjectFieldPathBuilder::new_with_base(self.path)
4103        }
4104    }
4105    impl BatchGetObjectsRequest {
4106        pub const REQUESTS_FIELD: &'static MessageField = &MessageField {
4107            name: "requests",
4108            json_name: "requests",
4109            number: 1i32,
4110            message_fields: Some(GetObjectRequest::FIELDS),
4111        };
4112        pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
4113            name: "read_mask",
4114            json_name: "readMask",
4115            number: 2i32,
4116            message_fields: None,
4117        };
4118    }
4119    impl MessageFields for BatchGetObjectsRequest {
4120        const FIELDS: &'static [&'static MessageField] = &[
4121            Self::REQUESTS_FIELD,
4122            Self::READ_MASK_FIELD,
4123        ];
4124    }
4125    impl BatchGetObjectsRequest {
4126        pub fn path_builder() -> BatchGetObjectsRequestFieldPathBuilder {
4127            BatchGetObjectsRequestFieldPathBuilder::new()
4128        }
4129    }
4130    pub struct BatchGetObjectsRequestFieldPathBuilder {
4131        path: Vec<&'static str>,
4132    }
4133    impl BatchGetObjectsRequestFieldPathBuilder {
4134        #[allow(clippy::new_without_default)]
4135        pub fn new() -> Self {
4136            Self { path: Default::default() }
4137        }
4138        #[doc(hidden)]
4139        pub fn new_with_base(base: Vec<&'static str>) -> Self {
4140            Self { path: base }
4141        }
4142        pub fn finish(self) -> String {
4143            self.path.join(".")
4144        }
4145        pub fn requests(mut self) -> GetObjectRequestFieldPathBuilder {
4146            self.path.push(BatchGetObjectsRequest::REQUESTS_FIELD.name);
4147            GetObjectRequestFieldPathBuilder::new_with_base(self.path)
4148        }
4149        pub fn read_mask(mut self) -> String {
4150            self.path.push(BatchGetObjectsRequest::READ_MASK_FIELD.name);
4151            self.finish()
4152        }
4153    }
4154    impl BatchGetObjectsResponse {
4155        pub const OBJECTS_FIELD: &'static MessageField = &MessageField {
4156            name: "objects",
4157            json_name: "objects",
4158            number: 1i32,
4159            message_fields: Some(GetObjectResult::FIELDS),
4160        };
4161    }
4162    impl MessageFields for BatchGetObjectsResponse {
4163        const FIELDS: &'static [&'static MessageField] = &[Self::OBJECTS_FIELD];
4164    }
4165    impl BatchGetObjectsResponse {
4166        pub fn path_builder() -> BatchGetObjectsResponseFieldPathBuilder {
4167            BatchGetObjectsResponseFieldPathBuilder::new()
4168        }
4169    }
4170    pub struct BatchGetObjectsResponseFieldPathBuilder {
4171        path: Vec<&'static str>,
4172    }
4173    impl BatchGetObjectsResponseFieldPathBuilder {
4174        #[allow(clippy::new_without_default)]
4175        pub fn new() -> Self {
4176            Self { path: Default::default() }
4177        }
4178        #[doc(hidden)]
4179        pub fn new_with_base(base: Vec<&'static str>) -> Self {
4180            Self { path: base }
4181        }
4182        pub fn finish(self) -> String {
4183            self.path.join(".")
4184        }
4185        pub fn objects(mut self) -> GetObjectResultFieldPathBuilder {
4186            self.path.push(BatchGetObjectsResponse::OBJECTS_FIELD.name);
4187            GetObjectResultFieldPathBuilder::new_with_base(self.path)
4188        }
4189    }
4190    impl GetObjectResult {
4191        pub const OBJECT_FIELD: &'static MessageField = &MessageField {
4192            name: "object",
4193            json_name: "object",
4194            number: 1i32,
4195            message_fields: Some(Object::FIELDS),
4196        };
4197        pub const ERROR_FIELD: &'static MessageField = &MessageField {
4198            name: "error",
4199            json_name: "error",
4200            number: 2i32,
4201            message_fields: None,
4202        };
4203    }
4204    impl MessageFields for GetObjectResult {
4205        const FIELDS: &'static [&'static MessageField] = &[
4206            Self::OBJECT_FIELD,
4207            Self::ERROR_FIELD,
4208        ];
4209    }
4210    impl GetObjectResult {
4211        pub fn path_builder() -> GetObjectResultFieldPathBuilder {
4212            GetObjectResultFieldPathBuilder::new()
4213        }
4214    }
4215    pub struct GetObjectResultFieldPathBuilder {
4216        path: Vec<&'static str>,
4217    }
4218    impl GetObjectResultFieldPathBuilder {
4219        #[allow(clippy::new_without_default)]
4220        pub fn new() -> Self {
4221            Self { path: Default::default() }
4222        }
4223        #[doc(hidden)]
4224        pub fn new_with_base(base: Vec<&'static str>) -> Self {
4225            Self { path: base }
4226        }
4227        pub fn finish(self) -> String {
4228            self.path.join(".")
4229        }
4230        pub fn object(mut self) -> ObjectFieldPathBuilder {
4231            self.path.push(GetObjectResult::OBJECT_FIELD.name);
4232            ObjectFieldPathBuilder::new_with_base(self.path)
4233        }
4234        pub fn error(mut self) -> String {
4235            self.path.push(GetObjectResult::ERROR_FIELD.name);
4236            self.finish()
4237        }
4238    }
4239    impl ListObjectVersionsRequest {
4240        pub const OBJECT_ID_FIELD: &'static MessageField = &MessageField {
4241            name: "object_id",
4242            json_name: "objectId",
4243            number: 1i32,
4244            message_fields: None,
4245        };
4246        pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
4247            name: "read_mask",
4248            json_name: "readMask",
4249            number: 2i32,
4250            message_fields: None,
4251        };
4252        pub const OPTIONS_FIELD: &'static MessageField = &MessageField {
4253            name: "options",
4254            json_name: "options",
4255            number: 3i32,
4256            message_fields: Some(QueryOptions::FIELDS),
4257        };
4258        pub const START_VERSION_FIELD: &'static MessageField = &MessageField {
4259            name: "start_version",
4260            json_name: "startVersion",
4261            number: 4i32,
4262            message_fields: None,
4263        };
4264        pub const END_VERSION_FIELD: &'static MessageField = &MessageField {
4265            name: "end_version",
4266            json_name: "endVersion",
4267            number: 5i32,
4268            message_fields: None,
4269        };
4270        pub const REMOVAL_READ_MASK_FIELD: &'static MessageField = &MessageField {
4271            name: "removal_read_mask",
4272            json_name: "removalReadMask",
4273            number: 7i32,
4274            message_fields: None,
4275        };
4276        pub const START_CHECKPOINT_FIELD: &'static MessageField = &MessageField {
4277            name: "start_checkpoint",
4278            json_name: "startCheckpoint",
4279            number: 8i32,
4280            message_fields: None,
4281        };
4282        pub const END_CHECKPOINT_FIELD: &'static MessageField = &MessageField {
4283            name: "end_checkpoint",
4284            json_name: "endCheckpoint",
4285            number: 9i32,
4286            message_fields: None,
4287        };
4288    }
4289    impl MessageFields for ListObjectVersionsRequest {
4290        const FIELDS: &'static [&'static MessageField] = &[
4291            Self::OBJECT_ID_FIELD,
4292            Self::READ_MASK_FIELD,
4293            Self::OPTIONS_FIELD,
4294            Self::START_VERSION_FIELD,
4295            Self::END_VERSION_FIELD,
4296            Self::REMOVAL_READ_MASK_FIELD,
4297            Self::START_CHECKPOINT_FIELD,
4298            Self::END_CHECKPOINT_FIELD,
4299        ];
4300    }
4301    impl ListObjectVersionsRequest {
4302        pub fn path_builder() -> ListObjectVersionsRequestFieldPathBuilder {
4303            ListObjectVersionsRequestFieldPathBuilder::new()
4304        }
4305    }
4306    pub struct ListObjectVersionsRequestFieldPathBuilder {
4307        path: Vec<&'static str>,
4308    }
4309    impl ListObjectVersionsRequestFieldPathBuilder {
4310        #[allow(clippy::new_without_default)]
4311        pub fn new() -> Self {
4312            Self { path: Default::default() }
4313        }
4314        #[doc(hidden)]
4315        pub fn new_with_base(base: Vec<&'static str>) -> Self {
4316            Self { path: base }
4317        }
4318        pub fn finish(self) -> String {
4319            self.path.join(".")
4320        }
4321        pub fn object_id(mut self) -> String {
4322            self.path.push(ListObjectVersionsRequest::OBJECT_ID_FIELD.name);
4323            self.finish()
4324        }
4325        pub fn read_mask(mut self) -> String {
4326            self.path.push(ListObjectVersionsRequest::READ_MASK_FIELD.name);
4327            self.finish()
4328        }
4329        pub fn options(mut self) -> QueryOptionsFieldPathBuilder {
4330            self.path.push(ListObjectVersionsRequest::OPTIONS_FIELD.name);
4331            QueryOptionsFieldPathBuilder::new_with_base(self.path)
4332        }
4333        pub fn start_version(mut self) -> String {
4334            self.path.push(ListObjectVersionsRequest::START_VERSION_FIELD.name);
4335            self.finish()
4336        }
4337        pub fn end_version(mut self) -> String {
4338            self.path.push(ListObjectVersionsRequest::END_VERSION_FIELD.name);
4339            self.finish()
4340        }
4341        pub fn removal_read_mask(mut self) -> String {
4342            self.path.push(ListObjectVersionsRequest::REMOVAL_READ_MASK_FIELD.name);
4343            self.finish()
4344        }
4345        pub fn start_checkpoint(mut self) -> String {
4346            self.path.push(ListObjectVersionsRequest::START_CHECKPOINT_FIELD.name);
4347            self.finish()
4348        }
4349        pub fn end_checkpoint(mut self) -> String {
4350            self.path.push(ListObjectVersionsRequest::END_CHECKPOINT_FIELD.name);
4351            self.finish()
4352        }
4353    }
4354    impl ListObjectVersionsResponse {
4355        pub const OBJECT_FIELD: &'static MessageField = &MessageField {
4356            name: "object",
4357            json_name: "object",
4358            number: 1i32,
4359            message_fields: Some(Object::FIELDS),
4360        };
4361        pub const REMOVAL_FIELD: &'static MessageField = &MessageField {
4362            name: "removal",
4363            json_name: "removal",
4364            number: 4i32,
4365            message_fields: Some(ObjectRemoval::FIELDS),
4366        };
4367        pub const CURSOR_FIELD: &'static MessageField = &MessageField {
4368            name: "cursor",
4369            json_name: "cursor",
4370            number: 2i32,
4371            message_fields: None,
4372        };
4373        pub const END_FIELD: &'static MessageField = &MessageField {
4374            name: "end",
4375            json_name: "end",
4376            number: 3i32,
4377            message_fields: Some(QueryEnd::FIELDS),
4378        };
4379    }
4380    impl MessageFields for ListObjectVersionsResponse {
4381        const FIELDS: &'static [&'static MessageField] = &[
4382            Self::OBJECT_FIELD,
4383            Self::REMOVAL_FIELD,
4384            Self::CURSOR_FIELD,
4385            Self::END_FIELD,
4386        ];
4387    }
4388    impl ListObjectVersionsResponse {
4389        pub fn path_builder() -> ListObjectVersionsResponseFieldPathBuilder {
4390            ListObjectVersionsResponseFieldPathBuilder::new()
4391        }
4392    }
4393    pub struct ListObjectVersionsResponseFieldPathBuilder {
4394        path: Vec<&'static str>,
4395    }
4396    impl ListObjectVersionsResponseFieldPathBuilder {
4397        #[allow(clippy::new_without_default)]
4398        pub fn new() -> Self {
4399            Self { path: Default::default() }
4400        }
4401        #[doc(hidden)]
4402        pub fn new_with_base(base: Vec<&'static str>) -> Self {
4403            Self { path: base }
4404        }
4405        pub fn finish(self) -> String {
4406            self.path.join(".")
4407        }
4408        pub fn object(mut self) -> ObjectFieldPathBuilder {
4409            self.path.push(ListObjectVersionsResponse::OBJECT_FIELD.name);
4410            ObjectFieldPathBuilder::new_with_base(self.path)
4411        }
4412        pub fn removal(mut self) -> ObjectRemovalFieldPathBuilder {
4413            self.path.push(ListObjectVersionsResponse::REMOVAL_FIELD.name);
4414            ObjectRemovalFieldPathBuilder::new_with_base(self.path)
4415        }
4416        pub fn cursor(mut self) -> String {
4417            self.path.push(ListObjectVersionsResponse::CURSOR_FIELD.name);
4418            self.finish()
4419        }
4420        pub fn end(mut self) -> QueryEndFieldPathBuilder {
4421            self.path.push(ListObjectVersionsResponse::END_FIELD.name);
4422            QueryEndFieldPathBuilder::new_with_base(self.path)
4423        }
4424    }
4425    impl ObjectRemoval {
4426        pub const VERSION_FIELD: &'static MessageField = &MessageField {
4427            name: "version",
4428            json_name: "version",
4429            number: 1i32,
4430            message_fields: None,
4431        };
4432        pub const KIND_FIELD: &'static MessageField = &MessageField {
4433            name: "kind",
4434            json_name: "kind",
4435            number: 2i32,
4436            message_fields: None,
4437        };
4438        pub const TRANSACTION_FIELD: &'static MessageField = &MessageField {
4439            name: "transaction",
4440            json_name: "transaction",
4441            number: 3i32,
4442            message_fields: None,
4443        };
4444    }
4445    impl MessageFields for ObjectRemoval {
4446        const FIELDS: &'static [&'static MessageField] = &[
4447            Self::VERSION_FIELD,
4448            Self::KIND_FIELD,
4449            Self::TRANSACTION_FIELD,
4450        ];
4451    }
4452    impl ObjectRemoval {
4453        pub fn path_builder() -> ObjectRemovalFieldPathBuilder {
4454            ObjectRemovalFieldPathBuilder::new()
4455        }
4456    }
4457    pub struct ObjectRemovalFieldPathBuilder {
4458        path: Vec<&'static str>,
4459    }
4460    impl ObjectRemovalFieldPathBuilder {
4461        #[allow(clippy::new_without_default)]
4462        pub fn new() -> Self {
4463            Self { path: Default::default() }
4464        }
4465        #[doc(hidden)]
4466        pub fn new_with_base(base: Vec<&'static str>) -> Self {
4467            Self { path: base }
4468        }
4469        pub fn finish(self) -> String {
4470            self.path.join(".")
4471        }
4472        pub fn version(mut self) -> String {
4473            self.path.push(ObjectRemoval::VERSION_FIELD.name);
4474            self.finish()
4475        }
4476        pub fn kind(mut self) -> String {
4477            self.path.push(ObjectRemoval::KIND_FIELD.name);
4478            self.finish()
4479        }
4480        pub fn transaction(mut self) -> String {
4481            self.path.push(ObjectRemoval::TRANSACTION_FIELD.name);
4482            self.finish()
4483        }
4484    }
4485    impl GetTransactionRequest {
4486        pub const DIGEST_FIELD: &'static MessageField = &MessageField {
4487            name: "digest",
4488            json_name: "digest",
4489            number: 1i32,
4490            message_fields: None,
4491        };
4492        pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
4493            name: "read_mask",
4494            json_name: "readMask",
4495            number: 2i32,
4496            message_fields: None,
4497        };
4498    }
4499    impl MessageFields for GetTransactionRequest {
4500        const FIELDS: &'static [&'static MessageField] = &[
4501            Self::DIGEST_FIELD,
4502            Self::READ_MASK_FIELD,
4503        ];
4504    }
4505    impl GetTransactionRequest {
4506        pub fn path_builder() -> GetTransactionRequestFieldPathBuilder {
4507            GetTransactionRequestFieldPathBuilder::new()
4508        }
4509    }
4510    pub struct GetTransactionRequestFieldPathBuilder {
4511        path: Vec<&'static str>,
4512    }
4513    impl GetTransactionRequestFieldPathBuilder {
4514        #[allow(clippy::new_without_default)]
4515        pub fn new() -> Self {
4516            Self { path: Default::default() }
4517        }
4518        #[doc(hidden)]
4519        pub fn new_with_base(base: Vec<&'static str>) -> Self {
4520            Self { path: base }
4521        }
4522        pub fn finish(self) -> String {
4523            self.path.join(".")
4524        }
4525        pub fn digest(mut self) -> String {
4526            self.path.push(GetTransactionRequest::DIGEST_FIELD.name);
4527            self.finish()
4528        }
4529        pub fn read_mask(mut self) -> String {
4530            self.path.push(GetTransactionRequest::READ_MASK_FIELD.name);
4531            self.finish()
4532        }
4533    }
4534    impl GetTransactionResponse {
4535        pub const TRANSACTION_FIELD: &'static MessageField = &MessageField {
4536            name: "transaction",
4537            json_name: "transaction",
4538            number: 1i32,
4539            message_fields: Some(ExecutedTransaction::FIELDS),
4540        };
4541    }
4542    impl MessageFields for GetTransactionResponse {
4543        const FIELDS: &'static [&'static MessageField] = &[Self::TRANSACTION_FIELD];
4544    }
4545    impl GetTransactionResponse {
4546        pub fn path_builder() -> GetTransactionResponseFieldPathBuilder {
4547            GetTransactionResponseFieldPathBuilder::new()
4548        }
4549    }
4550    pub struct GetTransactionResponseFieldPathBuilder {
4551        path: Vec<&'static str>,
4552    }
4553    impl GetTransactionResponseFieldPathBuilder {
4554        #[allow(clippy::new_without_default)]
4555        pub fn new() -> Self {
4556            Self { path: Default::default() }
4557        }
4558        #[doc(hidden)]
4559        pub fn new_with_base(base: Vec<&'static str>) -> Self {
4560            Self { path: base }
4561        }
4562        pub fn finish(self) -> String {
4563            self.path.join(".")
4564        }
4565        pub fn transaction(mut self) -> ExecutedTransactionFieldPathBuilder {
4566            self.path.push(GetTransactionResponse::TRANSACTION_FIELD.name);
4567            ExecutedTransactionFieldPathBuilder::new_with_base(self.path)
4568        }
4569    }
4570    impl BatchGetTransactionsRequest {
4571        pub const DIGESTS_FIELD: &'static MessageField = &MessageField {
4572            name: "digests",
4573            json_name: "digests",
4574            number: 1i32,
4575            message_fields: None,
4576        };
4577        pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
4578            name: "read_mask",
4579            json_name: "readMask",
4580            number: 2i32,
4581            message_fields: None,
4582        };
4583    }
4584    impl MessageFields for BatchGetTransactionsRequest {
4585        const FIELDS: &'static [&'static MessageField] = &[
4586            Self::DIGESTS_FIELD,
4587            Self::READ_MASK_FIELD,
4588        ];
4589    }
4590    impl BatchGetTransactionsRequest {
4591        pub fn path_builder() -> BatchGetTransactionsRequestFieldPathBuilder {
4592            BatchGetTransactionsRequestFieldPathBuilder::new()
4593        }
4594    }
4595    pub struct BatchGetTransactionsRequestFieldPathBuilder {
4596        path: Vec<&'static str>,
4597    }
4598    impl BatchGetTransactionsRequestFieldPathBuilder {
4599        #[allow(clippy::new_without_default)]
4600        pub fn new() -> Self {
4601            Self { path: Default::default() }
4602        }
4603        #[doc(hidden)]
4604        pub fn new_with_base(base: Vec<&'static str>) -> Self {
4605            Self { path: base }
4606        }
4607        pub fn finish(self) -> String {
4608            self.path.join(".")
4609        }
4610        pub fn digests(mut self) -> String {
4611            self.path.push(BatchGetTransactionsRequest::DIGESTS_FIELD.name);
4612            self.finish()
4613        }
4614        pub fn read_mask(mut self) -> String {
4615            self.path.push(BatchGetTransactionsRequest::READ_MASK_FIELD.name);
4616            self.finish()
4617        }
4618    }
4619    impl BatchGetTransactionsResponse {
4620        pub const TRANSACTIONS_FIELD: &'static MessageField = &MessageField {
4621            name: "transactions",
4622            json_name: "transactions",
4623            number: 1i32,
4624            message_fields: Some(GetTransactionResult::FIELDS),
4625        };
4626    }
4627    impl MessageFields for BatchGetTransactionsResponse {
4628        const FIELDS: &'static [&'static MessageField] = &[Self::TRANSACTIONS_FIELD];
4629    }
4630    impl BatchGetTransactionsResponse {
4631        pub fn path_builder() -> BatchGetTransactionsResponseFieldPathBuilder {
4632            BatchGetTransactionsResponseFieldPathBuilder::new()
4633        }
4634    }
4635    pub struct BatchGetTransactionsResponseFieldPathBuilder {
4636        path: Vec<&'static str>,
4637    }
4638    impl BatchGetTransactionsResponseFieldPathBuilder {
4639        #[allow(clippy::new_without_default)]
4640        pub fn new() -> Self {
4641            Self { path: Default::default() }
4642        }
4643        #[doc(hidden)]
4644        pub fn new_with_base(base: Vec<&'static str>) -> Self {
4645            Self { path: base }
4646        }
4647        pub fn finish(self) -> String {
4648            self.path.join(".")
4649        }
4650        pub fn transactions(mut self) -> GetTransactionResultFieldPathBuilder {
4651            self.path.push(BatchGetTransactionsResponse::TRANSACTIONS_FIELD.name);
4652            GetTransactionResultFieldPathBuilder::new_with_base(self.path)
4653        }
4654    }
4655    impl GetTransactionResult {
4656        pub const TRANSACTION_FIELD: &'static MessageField = &MessageField {
4657            name: "transaction",
4658            json_name: "transaction",
4659            number: 1i32,
4660            message_fields: Some(ExecutedTransaction::FIELDS),
4661        };
4662        pub const ERROR_FIELD: &'static MessageField = &MessageField {
4663            name: "error",
4664            json_name: "error",
4665            number: 2i32,
4666            message_fields: None,
4667        };
4668    }
4669    impl MessageFields for GetTransactionResult {
4670        const FIELDS: &'static [&'static MessageField] = &[
4671            Self::TRANSACTION_FIELD,
4672            Self::ERROR_FIELD,
4673        ];
4674    }
4675    impl GetTransactionResult {
4676        pub fn path_builder() -> GetTransactionResultFieldPathBuilder {
4677            GetTransactionResultFieldPathBuilder::new()
4678        }
4679    }
4680    pub struct GetTransactionResultFieldPathBuilder {
4681        path: Vec<&'static str>,
4682    }
4683    impl GetTransactionResultFieldPathBuilder {
4684        #[allow(clippy::new_without_default)]
4685        pub fn new() -> Self {
4686            Self { path: Default::default() }
4687        }
4688        #[doc(hidden)]
4689        pub fn new_with_base(base: Vec<&'static str>) -> Self {
4690            Self { path: base }
4691        }
4692        pub fn finish(self) -> String {
4693            self.path.join(".")
4694        }
4695        pub fn transaction(mut self) -> ExecutedTransactionFieldPathBuilder {
4696            self.path.push(GetTransactionResult::TRANSACTION_FIELD.name);
4697            ExecutedTransactionFieldPathBuilder::new_with_base(self.path)
4698        }
4699        pub fn error(mut self) -> String {
4700            self.path.push(GetTransactionResult::ERROR_FIELD.name);
4701            self.finish()
4702        }
4703    }
4704    impl GetCheckpointRequest {
4705        pub const SEQUENCE_NUMBER_FIELD: &'static MessageField = &MessageField {
4706            name: "sequence_number",
4707            json_name: "sequenceNumber",
4708            number: 1i32,
4709            message_fields: None,
4710        };
4711        pub const DIGEST_FIELD: &'static MessageField = &MessageField {
4712            name: "digest",
4713            json_name: "digest",
4714            number: 2i32,
4715            message_fields: None,
4716        };
4717        pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
4718            name: "read_mask",
4719            json_name: "readMask",
4720            number: 3i32,
4721            message_fields: None,
4722        };
4723    }
4724    impl MessageFields for GetCheckpointRequest {
4725        const FIELDS: &'static [&'static MessageField] = &[
4726            Self::SEQUENCE_NUMBER_FIELD,
4727            Self::DIGEST_FIELD,
4728            Self::READ_MASK_FIELD,
4729        ];
4730    }
4731    impl GetCheckpointRequest {
4732        pub fn path_builder() -> GetCheckpointRequestFieldPathBuilder {
4733            GetCheckpointRequestFieldPathBuilder::new()
4734        }
4735    }
4736    pub struct GetCheckpointRequestFieldPathBuilder {
4737        path: Vec<&'static str>,
4738    }
4739    impl GetCheckpointRequestFieldPathBuilder {
4740        #[allow(clippy::new_without_default)]
4741        pub fn new() -> Self {
4742            Self { path: Default::default() }
4743        }
4744        #[doc(hidden)]
4745        pub fn new_with_base(base: Vec<&'static str>) -> Self {
4746            Self { path: base }
4747        }
4748        pub fn finish(self) -> String {
4749            self.path.join(".")
4750        }
4751        pub fn sequence_number(mut self) -> String {
4752            self.path.push(GetCheckpointRequest::SEQUENCE_NUMBER_FIELD.name);
4753            self.finish()
4754        }
4755        pub fn digest(mut self) -> String {
4756            self.path.push(GetCheckpointRequest::DIGEST_FIELD.name);
4757            self.finish()
4758        }
4759        pub fn read_mask(mut self) -> String {
4760            self.path.push(GetCheckpointRequest::READ_MASK_FIELD.name);
4761            self.finish()
4762        }
4763    }
4764    impl GetCheckpointResponse {
4765        pub const CHECKPOINT_FIELD: &'static MessageField = &MessageField {
4766            name: "checkpoint",
4767            json_name: "checkpoint",
4768            number: 1i32,
4769            message_fields: Some(Checkpoint::FIELDS),
4770        };
4771    }
4772    impl MessageFields for GetCheckpointResponse {
4773        const FIELDS: &'static [&'static MessageField] = &[Self::CHECKPOINT_FIELD];
4774    }
4775    impl GetCheckpointResponse {
4776        pub fn path_builder() -> GetCheckpointResponseFieldPathBuilder {
4777            GetCheckpointResponseFieldPathBuilder::new()
4778        }
4779    }
4780    pub struct GetCheckpointResponseFieldPathBuilder {
4781        path: Vec<&'static str>,
4782    }
4783    impl GetCheckpointResponseFieldPathBuilder {
4784        #[allow(clippy::new_without_default)]
4785        pub fn new() -> Self {
4786            Self { path: Default::default() }
4787        }
4788        #[doc(hidden)]
4789        pub fn new_with_base(base: Vec<&'static str>) -> Self {
4790            Self { path: base }
4791        }
4792        pub fn finish(self) -> String {
4793            self.path.join(".")
4794        }
4795        pub fn checkpoint(mut self) -> CheckpointFieldPathBuilder {
4796            self.path.push(GetCheckpointResponse::CHECKPOINT_FIELD.name);
4797            CheckpointFieldPathBuilder::new_with_base(self.path)
4798        }
4799    }
4800    impl GetEpochRequest {
4801        pub const EPOCH_FIELD: &'static MessageField = &MessageField {
4802            name: "epoch",
4803            json_name: "epoch",
4804            number: 1i32,
4805            message_fields: None,
4806        };
4807        pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
4808            name: "read_mask",
4809            json_name: "readMask",
4810            number: 2i32,
4811            message_fields: None,
4812        };
4813    }
4814    impl MessageFields for GetEpochRequest {
4815        const FIELDS: &'static [&'static MessageField] = &[
4816            Self::EPOCH_FIELD,
4817            Self::READ_MASK_FIELD,
4818        ];
4819    }
4820    impl GetEpochRequest {
4821        pub fn path_builder() -> GetEpochRequestFieldPathBuilder {
4822            GetEpochRequestFieldPathBuilder::new()
4823        }
4824    }
4825    pub struct GetEpochRequestFieldPathBuilder {
4826        path: Vec<&'static str>,
4827    }
4828    impl GetEpochRequestFieldPathBuilder {
4829        #[allow(clippy::new_without_default)]
4830        pub fn new() -> Self {
4831            Self { path: Default::default() }
4832        }
4833        #[doc(hidden)]
4834        pub fn new_with_base(base: Vec<&'static str>) -> Self {
4835            Self { path: base }
4836        }
4837        pub fn finish(self) -> String {
4838            self.path.join(".")
4839        }
4840        pub fn epoch(mut self) -> String {
4841            self.path.push(GetEpochRequest::EPOCH_FIELD.name);
4842            self.finish()
4843        }
4844        pub fn read_mask(mut self) -> String {
4845            self.path.push(GetEpochRequest::READ_MASK_FIELD.name);
4846            self.finish()
4847        }
4848    }
4849    impl GetEpochResponse {
4850        pub const EPOCH_FIELD: &'static MessageField = &MessageField {
4851            name: "epoch",
4852            json_name: "epoch",
4853            number: 1i32,
4854            message_fields: Some(Epoch::FIELDS),
4855        };
4856    }
4857    impl MessageFields for GetEpochResponse {
4858        const FIELDS: &'static [&'static MessageField] = &[Self::EPOCH_FIELD];
4859    }
4860    impl GetEpochResponse {
4861        pub fn path_builder() -> GetEpochResponseFieldPathBuilder {
4862            GetEpochResponseFieldPathBuilder::new()
4863        }
4864    }
4865    pub struct GetEpochResponseFieldPathBuilder {
4866        path: Vec<&'static str>,
4867    }
4868    impl GetEpochResponseFieldPathBuilder {
4869        #[allow(clippy::new_without_default)]
4870        pub fn new() -> Self {
4871            Self { path: Default::default() }
4872        }
4873        #[doc(hidden)]
4874        pub fn new_with_base(base: Vec<&'static str>) -> Self {
4875            Self { path: base }
4876        }
4877        pub fn finish(self) -> String {
4878            self.path.join(".")
4879        }
4880        pub fn epoch(mut self) -> EpochFieldPathBuilder {
4881            self.path.push(GetEpochResponse::EPOCH_FIELD.name);
4882            EpochFieldPathBuilder::new_with_base(self.path)
4883        }
4884    }
4885    impl GetProtocolConfigRequest {
4886        pub const VERSION_FIELD: &'static MessageField = &MessageField {
4887            name: "version",
4888            json_name: "version",
4889            number: 1i32,
4890            message_fields: None,
4891        };
4892        pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
4893            name: "read_mask",
4894            json_name: "readMask",
4895            number: 2i32,
4896            message_fields: None,
4897        };
4898    }
4899    impl MessageFields for GetProtocolConfigRequest {
4900        const FIELDS: &'static [&'static MessageField] = &[
4901            Self::VERSION_FIELD,
4902            Self::READ_MASK_FIELD,
4903        ];
4904    }
4905    impl GetProtocolConfigRequest {
4906        pub fn path_builder() -> GetProtocolConfigRequestFieldPathBuilder {
4907            GetProtocolConfigRequestFieldPathBuilder::new()
4908        }
4909    }
4910    pub struct GetProtocolConfigRequestFieldPathBuilder {
4911        path: Vec<&'static str>,
4912    }
4913    impl GetProtocolConfigRequestFieldPathBuilder {
4914        #[allow(clippy::new_without_default)]
4915        pub fn new() -> Self {
4916            Self { path: Default::default() }
4917        }
4918        #[doc(hidden)]
4919        pub fn new_with_base(base: Vec<&'static str>) -> Self {
4920            Self { path: base }
4921        }
4922        pub fn finish(self) -> String {
4923            self.path.join(".")
4924        }
4925        pub fn version(mut self) -> String {
4926            self.path.push(GetProtocolConfigRequest::VERSION_FIELD.name);
4927            self.finish()
4928        }
4929        pub fn read_mask(mut self) -> String {
4930            self.path.push(GetProtocolConfigRequest::READ_MASK_FIELD.name);
4931            self.finish()
4932        }
4933    }
4934    impl GetProtocolConfigResponse {
4935        pub const PROTOCOL_CONFIG_FIELD: &'static MessageField = &MessageField {
4936            name: "protocol_config",
4937            json_name: "protocolConfig",
4938            number: 1i32,
4939            message_fields: Some(ProtocolConfig::FIELDS),
4940        };
4941    }
4942    impl MessageFields for GetProtocolConfigResponse {
4943        const FIELDS: &'static [&'static MessageField] = &[Self::PROTOCOL_CONFIG_FIELD];
4944    }
4945    impl GetProtocolConfigResponse {
4946        pub fn path_builder() -> GetProtocolConfigResponseFieldPathBuilder {
4947            GetProtocolConfigResponseFieldPathBuilder::new()
4948        }
4949    }
4950    pub struct GetProtocolConfigResponseFieldPathBuilder {
4951        path: Vec<&'static str>,
4952    }
4953    impl GetProtocolConfigResponseFieldPathBuilder {
4954        #[allow(clippy::new_without_default)]
4955        pub fn new() -> Self {
4956            Self { path: Default::default() }
4957        }
4958        #[doc(hidden)]
4959        pub fn new_with_base(base: Vec<&'static str>) -> Self {
4960            Self { path: base }
4961        }
4962        pub fn finish(self) -> String {
4963            self.path.join(".")
4964        }
4965        pub fn protocol_config(mut self) -> ProtocolConfigFieldPathBuilder {
4966            self.path.push(GetProtocolConfigResponse::PROTOCOL_CONFIG_FIELD.name);
4967            ProtocolConfigFieldPathBuilder::new_with_base(self.path)
4968        }
4969    }
4970    impl ListCheckpointsRequest {
4971        pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
4972            name: "read_mask",
4973            json_name: "readMask",
4974            number: 1i32,
4975            message_fields: None,
4976        };
4977        pub const START_CHECKPOINT_FIELD: &'static MessageField = &MessageField {
4978            name: "start_checkpoint",
4979            json_name: "startCheckpoint",
4980            number: 2i32,
4981            message_fields: None,
4982        };
4983        pub const END_CHECKPOINT_FIELD: &'static MessageField = &MessageField {
4984            name: "end_checkpoint",
4985            json_name: "endCheckpoint",
4986            number: 3i32,
4987            message_fields: None,
4988        };
4989        pub const FILTER_FIELD: &'static MessageField = &MessageField {
4990            name: "filter",
4991            json_name: "filter",
4992            number: 4i32,
4993            message_fields: Some(TransactionFilter::FIELDS),
4994        };
4995        pub const OPTIONS_FIELD: &'static MessageField = &MessageField {
4996            name: "options",
4997            json_name: "options",
4998            number: 5i32,
4999            message_fields: Some(QueryOptions::FIELDS),
5000        };
5001    }
5002    impl MessageFields for ListCheckpointsRequest {
5003        const FIELDS: &'static [&'static MessageField] = &[
5004            Self::READ_MASK_FIELD,
5005            Self::START_CHECKPOINT_FIELD,
5006            Self::END_CHECKPOINT_FIELD,
5007            Self::FILTER_FIELD,
5008            Self::OPTIONS_FIELD,
5009        ];
5010    }
5011    impl ListCheckpointsRequest {
5012        pub fn path_builder() -> ListCheckpointsRequestFieldPathBuilder {
5013            ListCheckpointsRequestFieldPathBuilder::new()
5014        }
5015    }
5016    pub struct ListCheckpointsRequestFieldPathBuilder {
5017        path: Vec<&'static str>,
5018    }
5019    impl ListCheckpointsRequestFieldPathBuilder {
5020        #[allow(clippy::new_without_default)]
5021        pub fn new() -> Self {
5022            Self { path: Default::default() }
5023        }
5024        #[doc(hidden)]
5025        pub fn new_with_base(base: Vec<&'static str>) -> Self {
5026            Self { path: base }
5027        }
5028        pub fn finish(self) -> String {
5029            self.path.join(".")
5030        }
5031        pub fn read_mask(mut self) -> String {
5032            self.path.push(ListCheckpointsRequest::READ_MASK_FIELD.name);
5033            self.finish()
5034        }
5035        pub fn start_checkpoint(mut self) -> String {
5036            self.path.push(ListCheckpointsRequest::START_CHECKPOINT_FIELD.name);
5037            self.finish()
5038        }
5039        pub fn end_checkpoint(mut self) -> String {
5040            self.path.push(ListCheckpointsRequest::END_CHECKPOINT_FIELD.name);
5041            self.finish()
5042        }
5043        pub fn filter(mut self) -> TransactionFilterFieldPathBuilder {
5044            self.path.push(ListCheckpointsRequest::FILTER_FIELD.name);
5045            TransactionFilterFieldPathBuilder::new_with_base(self.path)
5046        }
5047        pub fn options(mut self) -> QueryOptionsFieldPathBuilder {
5048            self.path.push(ListCheckpointsRequest::OPTIONS_FIELD.name);
5049            QueryOptionsFieldPathBuilder::new_with_base(self.path)
5050        }
5051    }
5052    impl ListCheckpointsResponse {
5053        pub const CHECKPOINT_FIELD: &'static MessageField = &MessageField {
5054            name: "checkpoint",
5055            json_name: "checkpoint",
5056            number: 1i32,
5057            message_fields: Some(Checkpoint::FIELDS),
5058        };
5059        pub const WATERMARK_FIELD: &'static MessageField = &MessageField {
5060            name: "watermark",
5061            json_name: "watermark",
5062            number: 2i32,
5063            message_fields: Some(Watermark::FIELDS),
5064        };
5065        pub const END_FIELD: &'static MessageField = &MessageField {
5066            name: "end",
5067            json_name: "end",
5068            number: 3i32,
5069            message_fields: Some(QueryEnd::FIELDS),
5070        };
5071    }
5072    impl MessageFields for ListCheckpointsResponse {
5073        const FIELDS: &'static [&'static MessageField] = &[
5074            Self::CHECKPOINT_FIELD,
5075            Self::WATERMARK_FIELD,
5076            Self::END_FIELD,
5077        ];
5078    }
5079    impl ListCheckpointsResponse {
5080        pub fn path_builder() -> ListCheckpointsResponseFieldPathBuilder {
5081            ListCheckpointsResponseFieldPathBuilder::new()
5082        }
5083    }
5084    pub struct ListCheckpointsResponseFieldPathBuilder {
5085        path: Vec<&'static str>,
5086    }
5087    impl ListCheckpointsResponseFieldPathBuilder {
5088        #[allow(clippy::new_without_default)]
5089        pub fn new() -> Self {
5090            Self { path: Default::default() }
5091        }
5092        #[doc(hidden)]
5093        pub fn new_with_base(base: Vec<&'static str>) -> Self {
5094            Self { path: base }
5095        }
5096        pub fn finish(self) -> String {
5097            self.path.join(".")
5098        }
5099        pub fn checkpoint(mut self) -> CheckpointFieldPathBuilder {
5100            self.path.push(ListCheckpointsResponse::CHECKPOINT_FIELD.name);
5101            CheckpointFieldPathBuilder::new_with_base(self.path)
5102        }
5103        pub fn watermark(mut self) -> WatermarkFieldPathBuilder {
5104            self.path.push(ListCheckpointsResponse::WATERMARK_FIELD.name);
5105            WatermarkFieldPathBuilder::new_with_base(self.path)
5106        }
5107        pub fn end(mut self) -> QueryEndFieldPathBuilder {
5108            self.path.push(ListCheckpointsResponse::END_FIELD.name);
5109            QueryEndFieldPathBuilder::new_with_base(self.path)
5110        }
5111    }
5112    impl ListTransactionsRequest {
5113        pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
5114            name: "read_mask",
5115            json_name: "readMask",
5116            number: 1i32,
5117            message_fields: None,
5118        };
5119        pub const START_CHECKPOINT_FIELD: &'static MessageField = &MessageField {
5120            name: "start_checkpoint",
5121            json_name: "startCheckpoint",
5122            number: 2i32,
5123            message_fields: None,
5124        };
5125        pub const END_CHECKPOINT_FIELD: &'static MessageField = &MessageField {
5126            name: "end_checkpoint",
5127            json_name: "endCheckpoint",
5128            number: 3i32,
5129            message_fields: None,
5130        };
5131        pub const FILTER_FIELD: &'static MessageField = &MessageField {
5132            name: "filter",
5133            json_name: "filter",
5134            number: 4i32,
5135            message_fields: Some(TransactionFilter::FIELDS),
5136        };
5137        pub const OPTIONS_FIELD: &'static MessageField = &MessageField {
5138            name: "options",
5139            json_name: "options",
5140            number: 5i32,
5141            message_fields: Some(QueryOptions::FIELDS),
5142        };
5143        pub const START_TRANSACTION_INDEX_FIELD: &'static MessageField = &MessageField {
5144            name: "start_transaction_index",
5145            json_name: "startTransactionIndex",
5146            number: 6i32,
5147            message_fields: None,
5148        };
5149        pub const END_TRANSACTION_INDEX_FIELD: &'static MessageField = &MessageField {
5150            name: "end_transaction_index",
5151            json_name: "endTransactionIndex",
5152            number: 7i32,
5153            message_fields: None,
5154        };
5155    }
5156    impl MessageFields for ListTransactionsRequest {
5157        const FIELDS: &'static [&'static MessageField] = &[
5158            Self::READ_MASK_FIELD,
5159            Self::START_CHECKPOINT_FIELD,
5160            Self::END_CHECKPOINT_FIELD,
5161            Self::FILTER_FIELD,
5162            Self::OPTIONS_FIELD,
5163            Self::START_TRANSACTION_INDEX_FIELD,
5164            Self::END_TRANSACTION_INDEX_FIELD,
5165        ];
5166    }
5167    impl ListTransactionsRequest {
5168        pub fn path_builder() -> ListTransactionsRequestFieldPathBuilder {
5169            ListTransactionsRequestFieldPathBuilder::new()
5170        }
5171    }
5172    pub struct ListTransactionsRequestFieldPathBuilder {
5173        path: Vec<&'static str>,
5174    }
5175    impl ListTransactionsRequestFieldPathBuilder {
5176        #[allow(clippy::new_without_default)]
5177        pub fn new() -> Self {
5178            Self { path: Default::default() }
5179        }
5180        #[doc(hidden)]
5181        pub fn new_with_base(base: Vec<&'static str>) -> Self {
5182            Self { path: base }
5183        }
5184        pub fn finish(self) -> String {
5185            self.path.join(".")
5186        }
5187        pub fn read_mask(mut self) -> String {
5188            self.path.push(ListTransactionsRequest::READ_MASK_FIELD.name);
5189            self.finish()
5190        }
5191        pub fn start_checkpoint(mut self) -> String {
5192            self.path.push(ListTransactionsRequest::START_CHECKPOINT_FIELD.name);
5193            self.finish()
5194        }
5195        pub fn end_checkpoint(mut self) -> String {
5196            self.path.push(ListTransactionsRequest::END_CHECKPOINT_FIELD.name);
5197            self.finish()
5198        }
5199        pub fn filter(mut self) -> TransactionFilterFieldPathBuilder {
5200            self.path.push(ListTransactionsRequest::FILTER_FIELD.name);
5201            TransactionFilterFieldPathBuilder::new_with_base(self.path)
5202        }
5203        pub fn options(mut self) -> QueryOptionsFieldPathBuilder {
5204            self.path.push(ListTransactionsRequest::OPTIONS_FIELD.name);
5205            QueryOptionsFieldPathBuilder::new_with_base(self.path)
5206        }
5207        pub fn start_transaction_index(mut self) -> String {
5208            self.path.push(ListTransactionsRequest::START_TRANSACTION_INDEX_FIELD.name);
5209            self.finish()
5210        }
5211        pub fn end_transaction_index(mut self) -> String {
5212            self.path.push(ListTransactionsRequest::END_TRANSACTION_INDEX_FIELD.name);
5213            self.finish()
5214        }
5215    }
5216    impl ListTransactionsResponse {
5217        pub const TRANSACTION_FIELD: &'static MessageField = &MessageField {
5218            name: "transaction",
5219            json_name: "transaction",
5220            number: 1i32,
5221            message_fields: Some(ExecutedTransaction::FIELDS),
5222        };
5223        pub const WATERMARK_FIELD: &'static MessageField = &MessageField {
5224            name: "watermark",
5225            json_name: "watermark",
5226            number: 2i32,
5227            message_fields: Some(Watermark::FIELDS),
5228        };
5229        pub const END_FIELD: &'static MessageField = &MessageField {
5230            name: "end",
5231            json_name: "end",
5232            number: 3i32,
5233            message_fields: Some(QueryEnd::FIELDS),
5234        };
5235    }
5236    impl MessageFields for ListTransactionsResponse {
5237        const FIELDS: &'static [&'static MessageField] = &[
5238            Self::TRANSACTION_FIELD,
5239            Self::WATERMARK_FIELD,
5240            Self::END_FIELD,
5241        ];
5242    }
5243    impl ListTransactionsResponse {
5244        pub fn path_builder() -> ListTransactionsResponseFieldPathBuilder {
5245            ListTransactionsResponseFieldPathBuilder::new()
5246        }
5247    }
5248    pub struct ListTransactionsResponseFieldPathBuilder {
5249        path: Vec<&'static str>,
5250    }
5251    impl ListTransactionsResponseFieldPathBuilder {
5252        #[allow(clippy::new_without_default)]
5253        pub fn new() -> Self {
5254            Self { path: Default::default() }
5255        }
5256        #[doc(hidden)]
5257        pub fn new_with_base(base: Vec<&'static str>) -> Self {
5258            Self { path: base }
5259        }
5260        pub fn finish(self) -> String {
5261            self.path.join(".")
5262        }
5263        pub fn transaction(mut self) -> ExecutedTransactionFieldPathBuilder {
5264            self.path.push(ListTransactionsResponse::TRANSACTION_FIELD.name);
5265            ExecutedTransactionFieldPathBuilder::new_with_base(self.path)
5266        }
5267        pub fn watermark(mut self) -> WatermarkFieldPathBuilder {
5268            self.path.push(ListTransactionsResponse::WATERMARK_FIELD.name);
5269            WatermarkFieldPathBuilder::new_with_base(self.path)
5270        }
5271        pub fn end(mut self) -> QueryEndFieldPathBuilder {
5272            self.path.push(ListTransactionsResponse::END_FIELD.name);
5273            QueryEndFieldPathBuilder::new_with_base(self.path)
5274        }
5275    }
5276    impl ListEventsRequest {
5277        pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
5278            name: "read_mask",
5279            json_name: "readMask",
5280            number: 1i32,
5281            message_fields: None,
5282        };
5283        pub const START_CHECKPOINT_FIELD: &'static MessageField = &MessageField {
5284            name: "start_checkpoint",
5285            json_name: "startCheckpoint",
5286            number: 2i32,
5287            message_fields: None,
5288        };
5289        pub const END_CHECKPOINT_FIELD: &'static MessageField = &MessageField {
5290            name: "end_checkpoint",
5291            json_name: "endCheckpoint",
5292            number: 3i32,
5293            message_fields: None,
5294        };
5295        pub const FILTER_FIELD: &'static MessageField = &MessageField {
5296            name: "filter",
5297            json_name: "filter",
5298            number: 4i32,
5299            message_fields: Some(EventFilter::FIELDS),
5300        };
5301        pub const OPTIONS_FIELD: &'static MessageField = &MessageField {
5302            name: "options",
5303            json_name: "options",
5304            number: 5i32,
5305            message_fields: Some(QueryOptions::FIELDS),
5306        };
5307        pub const START_TRANSACTION_INDEX_FIELD: &'static MessageField = &MessageField {
5308            name: "start_transaction_index",
5309            json_name: "startTransactionIndex",
5310            number: 6i32,
5311            message_fields: None,
5312        };
5313        pub const START_EVENT_INDEX_FIELD: &'static MessageField = &MessageField {
5314            name: "start_event_index",
5315            json_name: "startEventIndex",
5316            number: 7i32,
5317            message_fields: None,
5318        };
5319        pub const END_TRANSACTION_INDEX_FIELD: &'static MessageField = &MessageField {
5320            name: "end_transaction_index",
5321            json_name: "endTransactionIndex",
5322            number: 8i32,
5323            message_fields: None,
5324        };
5325        pub const END_EVENT_INDEX_FIELD: &'static MessageField = &MessageField {
5326            name: "end_event_index",
5327            json_name: "endEventIndex",
5328            number: 9i32,
5329            message_fields: None,
5330        };
5331    }
5332    impl MessageFields for ListEventsRequest {
5333        const FIELDS: &'static [&'static MessageField] = &[
5334            Self::READ_MASK_FIELD,
5335            Self::START_CHECKPOINT_FIELD,
5336            Self::END_CHECKPOINT_FIELD,
5337            Self::FILTER_FIELD,
5338            Self::OPTIONS_FIELD,
5339            Self::START_TRANSACTION_INDEX_FIELD,
5340            Self::START_EVENT_INDEX_FIELD,
5341            Self::END_TRANSACTION_INDEX_FIELD,
5342            Self::END_EVENT_INDEX_FIELD,
5343        ];
5344    }
5345    impl ListEventsRequest {
5346        pub fn path_builder() -> ListEventsRequestFieldPathBuilder {
5347            ListEventsRequestFieldPathBuilder::new()
5348        }
5349    }
5350    pub struct ListEventsRequestFieldPathBuilder {
5351        path: Vec<&'static str>,
5352    }
5353    impl ListEventsRequestFieldPathBuilder {
5354        #[allow(clippy::new_without_default)]
5355        pub fn new() -> Self {
5356            Self { path: Default::default() }
5357        }
5358        #[doc(hidden)]
5359        pub fn new_with_base(base: Vec<&'static str>) -> Self {
5360            Self { path: base }
5361        }
5362        pub fn finish(self) -> String {
5363            self.path.join(".")
5364        }
5365        pub fn read_mask(mut self) -> String {
5366            self.path.push(ListEventsRequest::READ_MASK_FIELD.name);
5367            self.finish()
5368        }
5369        pub fn start_checkpoint(mut self) -> String {
5370            self.path.push(ListEventsRequest::START_CHECKPOINT_FIELD.name);
5371            self.finish()
5372        }
5373        pub fn end_checkpoint(mut self) -> String {
5374            self.path.push(ListEventsRequest::END_CHECKPOINT_FIELD.name);
5375            self.finish()
5376        }
5377        pub fn filter(mut self) -> EventFilterFieldPathBuilder {
5378            self.path.push(ListEventsRequest::FILTER_FIELD.name);
5379            EventFilterFieldPathBuilder::new_with_base(self.path)
5380        }
5381        pub fn options(mut self) -> QueryOptionsFieldPathBuilder {
5382            self.path.push(ListEventsRequest::OPTIONS_FIELD.name);
5383            QueryOptionsFieldPathBuilder::new_with_base(self.path)
5384        }
5385        pub fn start_transaction_index(mut self) -> String {
5386            self.path.push(ListEventsRequest::START_TRANSACTION_INDEX_FIELD.name);
5387            self.finish()
5388        }
5389        pub fn start_event_index(mut self) -> String {
5390            self.path.push(ListEventsRequest::START_EVENT_INDEX_FIELD.name);
5391            self.finish()
5392        }
5393        pub fn end_transaction_index(mut self) -> String {
5394            self.path.push(ListEventsRequest::END_TRANSACTION_INDEX_FIELD.name);
5395            self.finish()
5396        }
5397        pub fn end_event_index(mut self) -> String {
5398            self.path.push(ListEventsRequest::END_EVENT_INDEX_FIELD.name);
5399            self.finish()
5400        }
5401    }
5402    impl ListEventsResponse {
5403        pub const EVENT_FIELD: &'static MessageField = &MessageField {
5404            name: "event",
5405            json_name: "event",
5406            number: 1i32,
5407            message_fields: Some(Event::FIELDS),
5408        };
5409        pub const WATERMARK_FIELD: &'static MessageField = &MessageField {
5410            name: "watermark",
5411            json_name: "watermark",
5412            number: 2i32,
5413            message_fields: Some(Watermark::FIELDS),
5414        };
5415        pub const END_FIELD: &'static MessageField = &MessageField {
5416            name: "end",
5417            json_name: "end",
5418            number: 3i32,
5419            message_fields: Some(QueryEnd::FIELDS),
5420        };
5421    }
5422    impl MessageFields for ListEventsResponse {
5423        const FIELDS: &'static [&'static MessageField] = &[
5424            Self::EVENT_FIELD,
5425            Self::WATERMARK_FIELD,
5426            Self::END_FIELD,
5427        ];
5428    }
5429    impl ListEventsResponse {
5430        pub fn path_builder() -> ListEventsResponseFieldPathBuilder {
5431            ListEventsResponseFieldPathBuilder::new()
5432        }
5433    }
5434    pub struct ListEventsResponseFieldPathBuilder {
5435        path: Vec<&'static str>,
5436    }
5437    impl ListEventsResponseFieldPathBuilder {
5438        #[allow(clippy::new_without_default)]
5439        pub fn new() -> Self {
5440            Self { path: Default::default() }
5441        }
5442        #[doc(hidden)]
5443        pub fn new_with_base(base: Vec<&'static str>) -> Self {
5444            Self { path: base }
5445        }
5446        pub fn finish(self) -> String {
5447            self.path.join(".")
5448        }
5449        pub fn event(mut self) -> EventFieldPathBuilder {
5450            self.path.push(ListEventsResponse::EVENT_FIELD.name);
5451            EventFieldPathBuilder::new_with_base(self.path)
5452        }
5453        pub fn watermark(mut self) -> WatermarkFieldPathBuilder {
5454            self.path.push(ListEventsResponse::WATERMARK_FIELD.name);
5455            WatermarkFieldPathBuilder::new_with_base(self.path)
5456        }
5457        pub fn end(mut self) -> QueryEndFieldPathBuilder {
5458            self.path.push(ListEventsResponse::END_FIELD.name);
5459            QueryEndFieldPathBuilder::new_with_base(self.path)
5460        }
5461    }
5462    impl Package {
5463        pub const STORAGE_ID_FIELD: &'static MessageField = &MessageField {
5464            name: "storage_id",
5465            json_name: "storageId",
5466            number: 1i32,
5467            message_fields: None,
5468        };
5469        pub const ORIGINAL_ID_FIELD: &'static MessageField = &MessageField {
5470            name: "original_id",
5471            json_name: "originalId",
5472            number: 2i32,
5473            message_fields: None,
5474        };
5475        pub const VERSION_FIELD: &'static MessageField = &MessageField {
5476            name: "version",
5477            json_name: "version",
5478            number: 3i32,
5479            message_fields: None,
5480        };
5481        pub const MODULES_FIELD: &'static MessageField = &MessageField {
5482            name: "modules",
5483            json_name: "modules",
5484            number: 4i32,
5485            message_fields: Some(Module::FIELDS),
5486        };
5487        pub const TYPE_ORIGINS_FIELD: &'static MessageField = &MessageField {
5488            name: "type_origins",
5489            json_name: "typeOrigins",
5490            number: 5i32,
5491            message_fields: Some(TypeOrigin::FIELDS),
5492        };
5493        pub const LINKAGE_FIELD: &'static MessageField = &MessageField {
5494            name: "linkage",
5495            json_name: "linkage",
5496            number: 6i32,
5497            message_fields: Some(Linkage::FIELDS),
5498        };
5499    }
5500    impl MessageFields for Package {
5501        const FIELDS: &'static [&'static MessageField] = &[
5502            Self::STORAGE_ID_FIELD,
5503            Self::ORIGINAL_ID_FIELD,
5504            Self::VERSION_FIELD,
5505            Self::MODULES_FIELD,
5506            Self::TYPE_ORIGINS_FIELD,
5507            Self::LINKAGE_FIELD,
5508        ];
5509    }
5510    impl Package {
5511        pub fn path_builder() -> PackageFieldPathBuilder {
5512            PackageFieldPathBuilder::new()
5513        }
5514    }
5515    pub struct PackageFieldPathBuilder {
5516        path: Vec<&'static str>,
5517    }
5518    impl PackageFieldPathBuilder {
5519        #[allow(clippy::new_without_default)]
5520        pub fn new() -> Self {
5521            Self { path: Default::default() }
5522        }
5523        #[doc(hidden)]
5524        pub fn new_with_base(base: Vec<&'static str>) -> Self {
5525            Self { path: base }
5526        }
5527        pub fn finish(self) -> String {
5528            self.path.join(".")
5529        }
5530        pub fn storage_id(mut self) -> String {
5531            self.path.push(Package::STORAGE_ID_FIELD.name);
5532            self.finish()
5533        }
5534        pub fn original_id(mut self) -> String {
5535            self.path.push(Package::ORIGINAL_ID_FIELD.name);
5536            self.finish()
5537        }
5538        pub fn version(mut self) -> String {
5539            self.path.push(Package::VERSION_FIELD.name);
5540            self.finish()
5541        }
5542        pub fn modules(mut self) -> ModuleFieldPathBuilder {
5543            self.path.push(Package::MODULES_FIELD.name);
5544            ModuleFieldPathBuilder::new_with_base(self.path)
5545        }
5546        pub fn type_origins(mut self) -> TypeOriginFieldPathBuilder {
5547            self.path.push(Package::TYPE_ORIGINS_FIELD.name);
5548            TypeOriginFieldPathBuilder::new_with_base(self.path)
5549        }
5550        pub fn linkage(mut self) -> LinkageFieldPathBuilder {
5551            self.path.push(Package::LINKAGE_FIELD.name);
5552            LinkageFieldPathBuilder::new_with_base(self.path)
5553        }
5554    }
5555    impl Module {
5556        pub const NAME_FIELD: &'static MessageField = &MessageField {
5557            name: "name",
5558            json_name: "name",
5559            number: 1i32,
5560            message_fields: None,
5561        };
5562        pub const CONTENTS_FIELD: &'static MessageField = &MessageField {
5563            name: "contents",
5564            json_name: "contents",
5565            number: 2i32,
5566            message_fields: None,
5567        };
5568        pub const DATATYPES_FIELD: &'static MessageField = &MessageField {
5569            name: "datatypes",
5570            json_name: "datatypes",
5571            number: 3i32,
5572            message_fields: Some(DatatypeDescriptor::FIELDS),
5573        };
5574        pub const FUNCTIONS_FIELD: &'static MessageField = &MessageField {
5575            name: "functions",
5576            json_name: "functions",
5577            number: 4i32,
5578            message_fields: Some(FunctionDescriptor::FIELDS),
5579        };
5580    }
5581    impl MessageFields for Module {
5582        const FIELDS: &'static [&'static MessageField] = &[
5583            Self::NAME_FIELD,
5584            Self::CONTENTS_FIELD,
5585            Self::DATATYPES_FIELD,
5586            Self::FUNCTIONS_FIELD,
5587        ];
5588    }
5589    impl Module {
5590        pub fn path_builder() -> ModuleFieldPathBuilder {
5591            ModuleFieldPathBuilder::new()
5592        }
5593    }
5594    pub struct ModuleFieldPathBuilder {
5595        path: Vec<&'static str>,
5596    }
5597    impl ModuleFieldPathBuilder {
5598        #[allow(clippy::new_without_default)]
5599        pub fn new() -> Self {
5600            Self { path: Default::default() }
5601        }
5602        #[doc(hidden)]
5603        pub fn new_with_base(base: Vec<&'static str>) -> Self {
5604            Self { path: base }
5605        }
5606        pub fn finish(self) -> String {
5607            self.path.join(".")
5608        }
5609        pub fn name(mut self) -> String {
5610            self.path.push(Module::NAME_FIELD.name);
5611            self.finish()
5612        }
5613        pub fn contents(mut self) -> String {
5614            self.path.push(Module::CONTENTS_FIELD.name);
5615            self.finish()
5616        }
5617        pub fn datatypes(mut self) -> DatatypeDescriptorFieldPathBuilder {
5618            self.path.push(Module::DATATYPES_FIELD.name);
5619            DatatypeDescriptorFieldPathBuilder::new_with_base(self.path)
5620        }
5621        pub fn functions(mut self) -> FunctionDescriptorFieldPathBuilder {
5622            self.path.push(Module::FUNCTIONS_FIELD.name);
5623            FunctionDescriptorFieldPathBuilder::new_with_base(self.path)
5624        }
5625    }
5626    impl DatatypeDescriptor {
5627        pub const TYPE_NAME_FIELD: &'static MessageField = &MessageField {
5628            name: "type_name",
5629            json_name: "typeName",
5630            number: 1i32,
5631            message_fields: None,
5632        };
5633        pub const DEFINING_ID_FIELD: &'static MessageField = &MessageField {
5634            name: "defining_id",
5635            json_name: "definingId",
5636            number: 2i32,
5637            message_fields: None,
5638        };
5639        pub const MODULE_FIELD: &'static MessageField = &MessageField {
5640            name: "module",
5641            json_name: "module",
5642            number: 3i32,
5643            message_fields: None,
5644        };
5645        pub const NAME_FIELD: &'static MessageField = &MessageField {
5646            name: "name",
5647            json_name: "name",
5648            number: 4i32,
5649            message_fields: None,
5650        };
5651        pub const ABILITIES_FIELD: &'static MessageField = &MessageField {
5652            name: "abilities",
5653            json_name: "abilities",
5654            number: 5i32,
5655            message_fields: None,
5656        };
5657        pub const TYPE_PARAMETERS_FIELD: &'static MessageField = &MessageField {
5658            name: "type_parameters",
5659            json_name: "typeParameters",
5660            number: 6i32,
5661            message_fields: Some(TypeParameter::FIELDS),
5662        };
5663        pub const KIND_FIELD: &'static MessageField = &MessageField {
5664            name: "kind",
5665            json_name: "kind",
5666            number: 7i32,
5667            message_fields: None,
5668        };
5669        pub const FIELDS_FIELD: &'static MessageField = &MessageField {
5670            name: "fields",
5671            json_name: "fields",
5672            number: 8i32,
5673            message_fields: Some(FieldDescriptor::FIELDS),
5674        };
5675        pub const VARIANTS_FIELD: &'static MessageField = &MessageField {
5676            name: "variants",
5677            json_name: "variants",
5678            number: 9i32,
5679            message_fields: Some(VariantDescriptor::FIELDS),
5680        };
5681    }
5682    impl MessageFields for DatatypeDescriptor {
5683        const FIELDS: &'static [&'static MessageField] = &[
5684            Self::TYPE_NAME_FIELD,
5685            Self::DEFINING_ID_FIELD,
5686            Self::MODULE_FIELD,
5687            Self::NAME_FIELD,
5688            Self::ABILITIES_FIELD,
5689            Self::TYPE_PARAMETERS_FIELD,
5690            Self::KIND_FIELD,
5691            Self::FIELDS_FIELD,
5692            Self::VARIANTS_FIELD,
5693        ];
5694    }
5695    impl DatatypeDescriptor {
5696        pub fn path_builder() -> DatatypeDescriptorFieldPathBuilder {
5697            DatatypeDescriptorFieldPathBuilder::new()
5698        }
5699    }
5700    pub struct DatatypeDescriptorFieldPathBuilder {
5701        path: Vec<&'static str>,
5702    }
5703    impl DatatypeDescriptorFieldPathBuilder {
5704        #[allow(clippy::new_without_default)]
5705        pub fn new() -> Self {
5706            Self { path: Default::default() }
5707        }
5708        #[doc(hidden)]
5709        pub fn new_with_base(base: Vec<&'static str>) -> Self {
5710            Self { path: base }
5711        }
5712        pub fn finish(self) -> String {
5713            self.path.join(".")
5714        }
5715        pub fn type_name(mut self) -> String {
5716            self.path.push(DatatypeDescriptor::TYPE_NAME_FIELD.name);
5717            self.finish()
5718        }
5719        pub fn defining_id(mut self) -> String {
5720            self.path.push(DatatypeDescriptor::DEFINING_ID_FIELD.name);
5721            self.finish()
5722        }
5723        pub fn module(mut self) -> String {
5724            self.path.push(DatatypeDescriptor::MODULE_FIELD.name);
5725            self.finish()
5726        }
5727        pub fn name(mut self) -> String {
5728            self.path.push(DatatypeDescriptor::NAME_FIELD.name);
5729            self.finish()
5730        }
5731        pub fn abilities(mut self) -> String {
5732            self.path.push(DatatypeDescriptor::ABILITIES_FIELD.name);
5733            self.finish()
5734        }
5735        pub fn type_parameters(mut self) -> TypeParameterFieldPathBuilder {
5736            self.path.push(DatatypeDescriptor::TYPE_PARAMETERS_FIELD.name);
5737            TypeParameterFieldPathBuilder::new_with_base(self.path)
5738        }
5739        pub fn kind(mut self) -> String {
5740            self.path.push(DatatypeDescriptor::KIND_FIELD.name);
5741            self.finish()
5742        }
5743        pub fn fields(mut self) -> FieldDescriptorFieldPathBuilder {
5744            self.path.push(DatatypeDescriptor::FIELDS_FIELD.name);
5745            FieldDescriptorFieldPathBuilder::new_with_base(self.path)
5746        }
5747        pub fn variants(mut self) -> VariantDescriptorFieldPathBuilder {
5748            self.path.push(DatatypeDescriptor::VARIANTS_FIELD.name);
5749            VariantDescriptorFieldPathBuilder::new_with_base(self.path)
5750        }
5751    }
5752    impl TypeParameter {
5753        pub const CONSTRAINTS_FIELD: &'static MessageField = &MessageField {
5754            name: "constraints",
5755            json_name: "constraints",
5756            number: 1i32,
5757            message_fields: None,
5758        };
5759        pub const IS_PHANTOM_FIELD: &'static MessageField = &MessageField {
5760            name: "is_phantom",
5761            json_name: "isPhantom",
5762            number: 2i32,
5763            message_fields: None,
5764        };
5765    }
5766    impl MessageFields for TypeParameter {
5767        const FIELDS: &'static [&'static MessageField] = &[
5768            Self::CONSTRAINTS_FIELD,
5769            Self::IS_PHANTOM_FIELD,
5770        ];
5771    }
5772    impl TypeParameter {
5773        pub fn path_builder() -> TypeParameterFieldPathBuilder {
5774            TypeParameterFieldPathBuilder::new()
5775        }
5776    }
5777    pub struct TypeParameterFieldPathBuilder {
5778        path: Vec<&'static str>,
5779    }
5780    impl TypeParameterFieldPathBuilder {
5781        #[allow(clippy::new_without_default)]
5782        pub fn new() -> Self {
5783            Self { path: Default::default() }
5784        }
5785        #[doc(hidden)]
5786        pub fn new_with_base(base: Vec<&'static str>) -> Self {
5787            Self { path: base }
5788        }
5789        pub fn finish(self) -> String {
5790            self.path.join(".")
5791        }
5792        pub fn constraints(mut self) -> String {
5793            self.path.push(TypeParameter::CONSTRAINTS_FIELD.name);
5794            self.finish()
5795        }
5796        pub fn is_phantom(mut self) -> String {
5797            self.path.push(TypeParameter::IS_PHANTOM_FIELD.name);
5798            self.finish()
5799        }
5800    }
5801    impl FieldDescriptor {
5802        pub const NAME_FIELD: &'static MessageField = &MessageField {
5803            name: "name",
5804            json_name: "name",
5805            number: 1i32,
5806            message_fields: None,
5807        };
5808        pub const POSITION_FIELD: &'static MessageField = &MessageField {
5809            name: "position",
5810            json_name: "position",
5811            number: 2i32,
5812            message_fields: None,
5813        };
5814        pub const TYPE_FIELD: &'static MessageField = &MessageField {
5815            name: "type",
5816            json_name: "type",
5817            number: 3i32,
5818            message_fields: Some(OpenSignatureBody::FIELDS),
5819        };
5820    }
5821    impl MessageFields for FieldDescriptor {
5822        const FIELDS: &'static [&'static MessageField] = &[
5823            Self::NAME_FIELD,
5824            Self::POSITION_FIELD,
5825            Self::TYPE_FIELD,
5826        ];
5827    }
5828    impl FieldDescriptor {
5829        pub fn path_builder() -> FieldDescriptorFieldPathBuilder {
5830            FieldDescriptorFieldPathBuilder::new()
5831        }
5832    }
5833    pub struct FieldDescriptorFieldPathBuilder {
5834        path: Vec<&'static str>,
5835    }
5836    impl FieldDescriptorFieldPathBuilder {
5837        #[allow(clippy::new_without_default)]
5838        pub fn new() -> Self {
5839            Self { path: Default::default() }
5840        }
5841        #[doc(hidden)]
5842        pub fn new_with_base(base: Vec<&'static str>) -> Self {
5843            Self { path: base }
5844        }
5845        pub fn finish(self) -> String {
5846            self.path.join(".")
5847        }
5848        pub fn name(mut self) -> String {
5849            self.path.push(FieldDescriptor::NAME_FIELD.name);
5850            self.finish()
5851        }
5852        pub fn position(mut self) -> String {
5853            self.path.push(FieldDescriptor::POSITION_FIELD.name);
5854            self.finish()
5855        }
5856        pub fn r#type(mut self) -> OpenSignatureBodyFieldPathBuilder {
5857            self.path.push(FieldDescriptor::TYPE_FIELD.name);
5858            OpenSignatureBodyFieldPathBuilder::new_with_base(self.path)
5859        }
5860    }
5861    impl VariantDescriptor {
5862        pub const NAME_FIELD: &'static MessageField = &MessageField {
5863            name: "name",
5864            json_name: "name",
5865            number: 1i32,
5866            message_fields: None,
5867        };
5868        pub const POSITION_FIELD: &'static MessageField = &MessageField {
5869            name: "position",
5870            json_name: "position",
5871            number: 2i32,
5872            message_fields: None,
5873        };
5874        pub const FIELDS_FIELD: &'static MessageField = &MessageField {
5875            name: "fields",
5876            json_name: "fields",
5877            number: 3i32,
5878            message_fields: Some(FieldDescriptor::FIELDS),
5879        };
5880    }
5881    impl MessageFields for VariantDescriptor {
5882        const FIELDS: &'static [&'static MessageField] = &[
5883            Self::NAME_FIELD,
5884            Self::POSITION_FIELD,
5885            Self::FIELDS_FIELD,
5886        ];
5887    }
5888    impl VariantDescriptor {
5889        pub fn path_builder() -> VariantDescriptorFieldPathBuilder {
5890            VariantDescriptorFieldPathBuilder::new()
5891        }
5892    }
5893    pub struct VariantDescriptorFieldPathBuilder {
5894        path: Vec<&'static str>,
5895    }
5896    impl VariantDescriptorFieldPathBuilder {
5897        #[allow(clippy::new_without_default)]
5898        pub fn new() -> Self {
5899            Self { path: Default::default() }
5900        }
5901        #[doc(hidden)]
5902        pub fn new_with_base(base: Vec<&'static str>) -> Self {
5903            Self { path: base }
5904        }
5905        pub fn finish(self) -> String {
5906            self.path.join(".")
5907        }
5908        pub fn name(mut self) -> String {
5909            self.path.push(VariantDescriptor::NAME_FIELD.name);
5910            self.finish()
5911        }
5912        pub fn position(mut self) -> String {
5913            self.path.push(VariantDescriptor::POSITION_FIELD.name);
5914            self.finish()
5915        }
5916        pub fn fields(mut self) -> FieldDescriptorFieldPathBuilder {
5917            self.path.push(VariantDescriptor::FIELDS_FIELD.name);
5918            FieldDescriptorFieldPathBuilder::new_with_base(self.path)
5919        }
5920    }
5921    impl OpenSignatureBody {
5922        pub const TYPE_FIELD: &'static MessageField = &MessageField {
5923            name: "type",
5924            json_name: "type",
5925            number: 1i32,
5926            message_fields: None,
5927        };
5928        pub const TYPE_NAME_FIELD: &'static MessageField = &MessageField {
5929            name: "type_name",
5930            json_name: "typeName",
5931            number: 2i32,
5932            message_fields: None,
5933        };
5934        pub const TYPE_PARAMETER_INSTANTIATION_FIELD: &'static MessageField = &MessageField {
5935            name: "type_parameter_instantiation",
5936            json_name: "typeParameterInstantiation",
5937            number: 3i32,
5938            message_fields: None,
5939        };
5940        pub const TYPE_PARAMETER_FIELD: &'static MessageField = &MessageField {
5941            name: "type_parameter",
5942            json_name: "typeParameter",
5943            number: 4i32,
5944            message_fields: None,
5945        };
5946    }
5947    impl MessageFields for OpenSignatureBody {
5948        const FIELDS: &'static [&'static MessageField] = &[
5949            Self::TYPE_FIELD,
5950            Self::TYPE_NAME_FIELD,
5951            Self::TYPE_PARAMETER_INSTANTIATION_FIELD,
5952            Self::TYPE_PARAMETER_FIELD,
5953        ];
5954    }
5955    impl OpenSignatureBody {
5956        pub fn path_builder() -> OpenSignatureBodyFieldPathBuilder {
5957            OpenSignatureBodyFieldPathBuilder::new()
5958        }
5959    }
5960    pub struct OpenSignatureBodyFieldPathBuilder {
5961        path: Vec<&'static str>,
5962    }
5963    impl OpenSignatureBodyFieldPathBuilder {
5964        #[allow(clippy::new_without_default)]
5965        pub fn new() -> Self {
5966            Self { path: Default::default() }
5967        }
5968        #[doc(hidden)]
5969        pub fn new_with_base(base: Vec<&'static str>) -> Self {
5970            Self { path: base }
5971        }
5972        pub fn finish(self) -> String {
5973            self.path.join(".")
5974        }
5975        pub fn r#type(mut self) -> String {
5976            self.path.push(OpenSignatureBody::TYPE_FIELD.name);
5977            self.finish()
5978        }
5979        pub fn type_name(mut self) -> String {
5980            self.path.push(OpenSignatureBody::TYPE_NAME_FIELD.name);
5981            self.finish()
5982        }
5983        pub fn type_parameter_instantiation(mut self) -> String {
5984            self.path.push(OpenSignatureBody::TYPE_PARAMETER_INSTANTIATION_FIELD.name);
5985            self.finish()
5986        }
5987        pub fn type_parameter(mut self) -> String {
5988            self.path.push(OpenSignatureBody::TYPE_PARAMETER_FIELD.name);
5989            self.finish()
5990        }
5991    }
5992    impl FunctionDescriptor {
5993        pub const NAME_FIELD: &'static MessageField = &MessageField {
5994            name: "name",
5995            json_name: "name",
5996            number: 1i32,
5997            message_fields: None,
5998        };
5999        pub const VISIBILITY_FIELD: &'static MessageField = &MessageField {
6000            name: "visibility",
6001            json_name: "visibility",
6002            number: 5i32,
6003            message_fields: None,
6004        };
6005        pub const IS_ENTRY_FIELD: &'static MessageField = &MessageField {
6006            name: "is_entry",
6007            json_name: "isEntry",
6008            number: 6i32,
6009            message_fields: None,
6010        };
6011        pub const TYPE_PARAMETERS_FIELD: &'static MessageField = &MessageField {
6012            name: "type_parameters",
6013            json_name: "typeParameters",
6014            number: 7i32,
6015            message_fields: Some(TypeParameter::FIELDS),
6016        };
6017        pub const PARAMETERS_FIELD: &'static MessageField = &MessageField {
6018            name: "parameters",
6019            json_name: "parameters",
6020            number: 8i32,
6021            message_fields: Some(OpenSignature::FIELDS),
6022        };
6023        pub const RETURNS_FIELD: &'static MessageField = &MessageField {
6024            name: "returns",
6025            json_name: "returns",
6026            number: 9i32,
6027            message_fields: Some(OpenSignature::FIELDS),
6028        };
6029    }
6030    impl MessageFields for FunctionDescriptor {
6031        const FIELDS: &'static [&'static MessageField] = &[
6032            Self::NAME_FIELD,
6033            Self::VISIBILITY_FIELD,
6034            Self::IS_ENTRY_FIELD,
6035            Self::TYPE_PARAMETERS_FIELD,
6036            Self::PARAMETERS_FIELD,
6037            Self::RETURNS_FIELD,
6038        ];
6039    }
6040    impl FunctionDescriptor {
6041        pub fn path_builder() -> FunctionDescriptorFieldPathBuilder {
6042            FunctionDescriptorFieldPathBuilder::new()
6043        }
6044    }
6045    pub struct FunctionDescriptorFieldPathBuilder {
6046        path: Vec<&'static str>,
6047    }
6048    impl FunctionDescriptorFieldPathBuilder {
6049        #[allow(clippy::new_without_default)]
6050        pub fn new() -> Self {
6051            Self { path: Default::default() }
6052        }
6053        #[doc(hidden)]
6054        pub fn new_with_base(base: Vec<&'static str>) -> Self {
6055            Self { path: base }
6056        }
6057        pub fn finish(self) -> String {
6058            self.path.join(".")
6059        }
6060        pub fn name(mut self) -> String {
6061            self.path.push(FunctionDescriptor::NAME_FIELD.name);
6062            self.finish()
6063        }
6064        pub fn visibility(mut self) -> String {
6065            self.path.push(FunctionDescriptor::VISIBILITY_FIELD.name);
6066            self.finish()
6067        }
6068        pub fn is_entry(mut self) -> String {
6069            self.path.push(FunctionDescriptor::IS_ENTRY_FIELD.name);
6070            self.finish()
6071        }
6072        pub fn type_parameters(mut self) -> TypeParameterFieldPathBuilder {
6073            self.path.push(FunctionDescriptor::TYPE_PARAMETERS_FIELD.name);
6074            TypeParameterFieldPathBuilder::new_with_base(self.path)
6075        }
6076        pub fn parameters(mut self) -> OpenSignatureFieldPathBuilder {
6077            self.path.push(FunctionDescriptor::PARAMETERS_FIELD.name);
6078            OpenSignatureFieldPathBuilder::new_with_base(self.path)
6079        }
6080        pub fn returns(mut self) -> OpenSignatureFieldPathBuilder {
6081            self.path.push(FunctionDescriptor::RETURNS_FIELD.name);
6082            OpenSignatureFieldPathBuilder::new_with_base(self.path)
6083        }
6084    }
6085    impl OpenSignature {
6086        pub const REFERENCE_FIELD: &'static MessageField = &MessageField {
6087            name: "reference",
6088            json_name: "reference",
6089            number: 1i32,
6090            message_fields: None,
6091        };
6092        pub const BODY_FIELD: &'static MessageField = &MessageField {
6093            name: "body",
6094            json_name: "body",
6095            number: 2i32,
6096            message_fields: Some(OpenSignatureBody::FIELDS),
6097        };
6098    }
6099    impl MessageFields for OpenSignature {
6100        const FIELDS: &'static [&'static MessageField] = &[
6101            Self::REFERENCE_FIELD,
6102            Self::BODY_FIELD,
6103        ];
6104    }
6105    impl OpenSignature {
6106        pub fn path_builder() -> OpenSignatureFieldPathBuilder {
6107            OpenSignatureFieldPathBuilder::new()
6108        }
6109    }
6110    pub struct OpenSignatureFieldPathBuilder {
6111        path: Vec<&'static str>,
6112    }
6113    impl OpenSignatureFieldPathBuilder {
6114        #[allow(clippy::new_without_default)]
6115        pub fn new() -> Self {
6116            Self { path: Default::default() }
6117        }
6118        #[doc(hidden)]
6119        pub fn new_with_base(base: Vec<&'static str>) -> Self {
6120            Self { path: base }
6121        }
6122        pub fn finish(self) -> String {
6123            self.path.join(".")
6124        }
6125        pub fn reference(mut self) -> String {
6126            self.path.push(OpenSignature::REFERENCE_FIELD.name);
6127            self.finish()
6128        }
6129        pub fn body(mut self) -> OpenSignatureBodyFieldPathBuilder {
6130            self.path.push(OpenSignature::BODY_FIELD.name);
6131            OpenSignatureBodyFieldPathBuilder::new_with_base(self.path)
6132        }
6133    }
6134    impl TypeOrigin {
6135        pub const MODULE_NAME_FIELD: &'static MessageField = &MessageField {
6136            name: "module_name",
6137            json_name: "moduleName",
6138            number: 1i32,
6139            message_fields: None,
6140        };
6141        pub const DATATYPE_NAME_FIELD: &'static MessageField = &MessageField {
6142            name: "datatype_name",
6143            json_name: "datatypeName",
6144            number: 2i32,
6145            message_fields: None,
6146        };
6147        pub const PACKAGE_ID_FIELD: &'static MessageField = &MessageField {
6148            name: "package_id",
6149            json_name: "packageId",
6150            number: 3i32,
6151            message_fields: None,
6152        };
6153    }
6154    impl MessageFields for TypeOrigin {
6155        const FIELDS: &'static [&'static MessageField] = &[
6156            Self::MODULE_NAME_FIELD,
6157            Self::DATATYPE_NAME_FIELD,
6158            Self::PACKAGE_ID_FIELD,
6159        ];
6160    }
6161    impl TypeOrigin {
6162        pub fn path_builder() -> TypeOriginFieldPathBuilder {
6163            TypeOriginFieldPathBuilder::new()
6164        }
6165    }
6166    pub struct TypeOriginFieldPathBuilder {
6167        path: Vec<&'static str>,
6168    }
6169    impl TypeOriginFieldPathBuilder {
6170        #[allow(clippy::new_without_default)]
6171        pub fn new() -> Self {
6172            Self { path: Default::default() }
6173        }
6174        #[doc(hidden)]
6175        pub fn new_with_base(base: Vec<&'static str>) -> Self {
6176            Self { path: base }
6177        }
6178        pub fn finish(self) -> String {
6179            self.path.join(".")
6180        }
6181        pub fn module_name(mut self) -> String {
6182            self.path.push(TypeOrigin::MODULE_NAME_FIELD.name);
6183            self.finish()
6184        }
6185        pub fn datatype_name(mut self) -> String {
6186            self.path.push(TypeOrigin::DATATYPE_NAME_FIELD.name);
6187            self.finish()
6188        }
6189        pub fn package_id(mut self) -> String {
6190            self.path.push(TypeOrigin::PACKAGE_ID_FIELD.name);
6191            self.finish()
6192        }
6193    }
6194    impl Linkage {
6195        pub const ORIGINAL_ID_FIELD: &'static MessageField = &MessageField {
6196            name: "original_id",
6197            json_name: "originalId",
6198            number: 1i32,
6199            message_fields: None,
6200        };
6201        pub const UPGRADED_ID_FIELD: &'static MessageField = &MessageField {
6202            name: "upgraded_id",
6203            json_name: "upgradedId",
6204            number: 2i32,
6205            message_fields: None,
6206        };
6207        pub const UPGRADED_VERSION_FIELD: &'static MessageField = &MessageField {
6208            name: "upgraded_version",
6209            json_name: "upgradedVersion",
6210            number: 3i32,
6211            message_fields: None,
6212        };
6213    }
6214    impl MessageFields for Linkage {
6215        const FIELDS: &'static [&'static MessageField] = &[
6216            Self::ORIGINAL_ID_FIELD,
6217            Self::UPGRADED_ID_FIELD,
6218            Self::UPGRADED_VERSION_FIELD,
6219        ];
6220    }
6221    impl Linkage {
6222        pub fn path_builder() -> LinkageFieldPathBuilder {
6223            LinkageFieldPathBuilder::new()
6224        }
6225    }
6226    pub struct LinkageFieldPathBuilder {
6227        path: Vec<&'static str>,
6228    }
6229    impl LinkageFieldPathBuilder {
6230        #[allow(clippy::new_without_default)]
6231        pub fn new() -> Self {
6232            Self { path: Default::default() }
6233        }
6234        #[doc(hidden)]
6235        pub fn new_with_base(base: Vec<&'static str>) -> Self {
6236            Self { path: base }
6237        }
6238        pub fn finish(self) -> String {
6239            self.path.join(".")
6240        }
6241        pub fn original_id(mut self) -> String {
6242            self.path.push(Linkage::ORIGINAL_ID_FIELD.name);
6243            self.finish()
6244        }
6245        pub fn upgraded_id(mut self) -> String {
6246            self.path.push(Linkage::UPGRADED_ID_FIELD.name);
6247            self.finish()
6248        }
6249        pub fn upgraded_version(mut self) -> String {
6250            self.path.push(Linkage::UPGRADED_VERSION_FIELD.name);
6251            self.finish()
6252        }
6253    }
6254    impl GetPackageRequest {
6255        pub const PACKAGE_ID_FIELD: &'static MessageField = &MessageField {
6256            name: "package_id",
6257            json_name: "packageId",
6258            number: 1i32,
6259            message_fields: None,
6260        };
6261        pub const VERSION_FIELD: &'static MessageField = &MessageField {
6262            name: "version",
6263            json_name: "version",
6264            number: 2i32,
6265            message_fields: None,
6266        };
6267        pub const AT_CHECKPOINT_FIELD: &'static MessageField = &MessageField {
6268            name: "at_checkpoint",
6269            json_name: "atCheckpoint",
6270            number: 3i32,
6271            message_fields: None,
6272        };
6273    }
6274    impl MessageFields for GetPackageRequest {
6275        const FIELDS: &'static [&'static MessageField] = &[
6276            Self::PACKAGE_ID_FIELD,
6277            Self::VERSION_FIELD,
6278            Self::AT_CHECKPOINT_FIELD,
6279        ];
6280    }
6281    impl GetPackageRequest {
6282        pub fn path_builder() -> GetPackageRequestFieldPathBuilder {
6283            GetPackageRequestFieldPathBuilder::new()
6284        }
6285    }
6286    pub struct GetPackageRequestFieldPathBuilder {
6287        path: Vec<&'static str>,
6288    }
6289    impl GetPackageRequestFieldPathBuilder {
6290        #[allow(clippy::new_without_default)]
6291        pub fn new() -> Self {
6292            Self { path: Default::default() }
6293        }
6294        #[doc(hidden)]
6295        pub fn new_with_base(base: Vec<&'static str>) -> Self {
6296            Self { path: base }
6297        }
6298        pub fn finish(self) -> String {
6299            self.path.join(".")
6300        }
6301        pub fn package_id(mut self) -> String {
6302            self.path.push(GetPackageRequest::PACKAGE_ID_FIELD.name);
6303            self.finish()
6304        }
6305        pub fn version(mut self) -> String {
6306            self.path.push(GetPackageRequest::VERSION_FIELD.name);
6307            self.finish()
6308        }
6309        pub fn at_checkpoint(mut self) -> String {
6310            self.path.push(GetPackageRequest::AT_CHECKPOINT_FIELD.name);
6311            self.finish()
6312        }
6313    }
6314    impl GetPackageResponse {
6315        pub const PACKAGE_FIELD: &'static MessageField = &MessageField {
6316            name: "package",
6317            json_name: "package",
6318            number: 1i32,
6319            message_fields: Some(Package::FIELDS),
6320        };
6321    }
6322    impl MessageFields for GetPackageResponse {
6323        const FIELDS: &'static [&'static MessageField] = &[Self::PACKAGE_FIELD];
6324    }
6325    impl GetPackageResponse {
6326        pub fn path_builder() -> GetPackageResponseFieldPathBuilder {
6327            GetPackageResponseFieldPathBuilder::new()
6328        }
6329    }
6330    pub struct GetPackageResponseFieldPathBuilder {
6331        path: Vec<&'static str>,
6332    }
6333    impl GetPackageResponseFieldPathBuilder {
6334        #[allow(clippy::new_without_default)]
6335        pub fn new() -> Self {
6336            Self { path: Default::default() }
6337        }
6338        #[doc(hidden)]
6339        pub fn new_with_base(base: Vec<&'static str>) -> Self {
6340            Self { path: base }
6341        }
6342        pub fn finish(self) -> String {
6343            self.path.join(".")
6344        }
6345        pub fn package(mut self) -> PackageFieldPathBuilder {
6346            self.path.push(GetPackageResponse::PACKAGE_FIELD.name);
6347            PackageFieldPathBuilder::new_with_base(self.path)
6348        }
6349    }
6350    impl GetDatatypeRequest {
6351        pub const PACKAGE_ID_FIELD: &'static MessageField = &MessageField {
6352            name: "package_id",
6353            json_name: "packageId",
6354            number: 1i32,
6355            message_fields: None,
6356        };
6357        pub const MODULE_NAME_FIELD: &'static MessageField = &MessageField {
6358            name: "module_name",
6359            json_name: "moduleName",
6360            number: 2i32,
6361            message_fields: None,
6362        };
6363        pub const NAME_FIELD: &'static MessageField = &MessageField {
6364            name: "name",
6365            json_name: "name",
6366            number: 3i32,
6367            message_fields: None,
6368        };
6369    }
6370    impl MessageFields for GetDatatypeRequest {
6371        const FIELDS: &'static [&'static MessageField] = &[
6372            Self::PACKAGE_ID_FIELD,
6373            Self::MODULE_NAME_FIELD,
6374            Self::NAME_FIELD,
6375        ];
6376    }
6377    impl GetDatatypeRequest {
6378        pub fn path_builder() -> GetDatatypeRequestFieldPathBuilder {
6379            GetDatatypeRequestFieldPathBuilder::new()
6380        }
6381    }
6382    pub struct GetDatatypeRequestFieldPathBuilder {
6383        path: Vec<&'static str>,
6384    }
6385    impl GetDatatypeRequestFieldPathBuilder {
6386        #[allow(clippy::new_without_default)]
6387        pub fn new() -> Self {
6388            Self { path: Default::default() }
6389        }
6390        #[doc(hidden)]
6391        pub fn new_with_base(base: Vec<&'static str>) -> Self {
6392            Self { path: base }
6393        }
6394        pub fn finish(self) -> String {
6395            self.path.join(".")
6396        }
6397        pub fn package_id(mut self) -> String {
6398            self.path.push(GetDatatypeRequest::PACKAGE_ID_FIELD.name);
6399            self.finish()
6400        }
6401        pub fn module_name(mut self) -> String {
6402            self.path.push(GetDatatypeRequest::MODULE_NAME_FIELD.name);
6403            self.finish()
6404        }
6405        pub fn name(mut self) -> String {
6406            self.path.push(GetDatatypeRequest::NAME_FIELD.name);
6407            self.finish()
6408        }
6409    }
6410    impl GetDatatypeResponse {
6411        pub const DATATYPE_FIELD: &'static MessageField = &MessageField {
6412            name: "datatype",
6413            json_name: "datatype",
6414            number: 1i32,
6415            message_fields: Some(DatatypeDescriptor::FIELDS),
6416        };
6417    }
6418    impl MessageFields for GetDatatypeResponse {
6419        const FIELDS: &'static [&'static MessageField] = &[Self::DATATYPE_FIELD];
6420    }
6421    impl GetDatatypeResponse {
6422        pub fn path_builder() -> GetDatatypeResponseFieldPathBuilder {
6423            GetDatatypeResponseFieldPathBuilder::new()
6424        }
6425    }
6426    pub struct GetDatatypeResponseFieldPathBuilder {
6427        path: Vec<&'static str>,
6428    }
6429    impl GetDatatypeResponseFieldPathBuilder {
6430        #[allow(clippy::new_without_default)]
6431        pub fn new() -> Self {
6432            Self { path: Default::default() }
6433        }
6434        #[doc(hidden)]
6435        pub fn new_with_base(base: Vec<&'static str>) -> Self {
6436            Self { path: base }
6437        }
6438        pub fn finish(self) -> String {
6439            self.path.join(".")
6440        }
6441        pub fn datatype(mut self) -> DatatypeDescriptorFieldPathBuilder {
6442            self.path.push(GetDatatypeResponse::DATATYPE_FIELD.name);
6443            DatatypeDescriptorFieldPathBuilder::new_with_base(self.path)
6444        }
6445    }
6446    impl GetFunctionRequest {
6447        pub const PACKAGE_ID_FIELD: &'static MessageField = &MessageField {
6448            name: "package_id",
6449            json_name: "packageId",
6450            number: 1i32,
6451            message_fields: None,
6452        };
6453        pub const MODULE_NAME_FIELD: &'static MessageField = &MessageField {
6454            name: "module_name",
6455            json_name: "moduleName",
6456            number: 2i32,
6457            message_fields: None,
6458        };
6459        pub const NAME_FIELD: &'static MessageField = &MessageField {
6460            name: "name",
6461            json_name: "name",
6462            number: 3i32,
6463            message_fields: None,
6464        };
6465    }
6466    impl MessageFields for GetFunctionRequest {
6467        const FIELDS: &'static [&'static MessageField] = &[
6468            Self::PACKAGE_ID_FIELD,
6469            Self::MODULE_NAME_FIELD,
6470            Self::NAME_FIELD,
6471        ];
6472    }
6473    impl GetFunctionRequest {
6474        pub fn path_builder() -> GetFunctionRequestFieldPathBuilder {
6475            GetFunctionRequestFieldPathBuilder::new()
6476        }
6477    }
6478    pub struct GetFunctionRequestFieldPathBuilder {
6479        path: Vec<&'static str>,
6480    }
6481    impl GetFunctionRequestFieldPathBuilder {
6482        #[allow(clippy::new_without_default)]
6483        pub fn new() -> Self {
6484            Self { path: Default::default() }
6485        }
6486        #[doc(hidden)]
6487        pub fn new_with_base(base: Vec<&'static str>) -> Self {
6488            Self { path: base }
6489        }
6490        pub fn finish(self) -> String {
6491            self.path.join(".")
6492        }
6493        pub fn package_id(mut self) -> String {
6494            self.path.push(GetFunctionRequest::PACKAGE_ID_FIELD.name);
6495            self.finish()
6496        }
6497        pub fn module_name(mut self) -> String {
6498            self.path.push(GetFunctionRequest::MODULE_NAME_FIELD.name);
6499            self.finish()
6500        }
6501        pub fn name(mut self) -> String {
6502            self.path.push(GetFunctionRequest::NAME_FIELD.name);
6503            self.finish()
6504        }
6505    }
6506    impl GetFunctionResponse {
6507        pub const FUNCTION_FIELD: &'static MessageField = &MessageField {
6508            name: "function",
6509            json_name: "function",
6510            number: 1i32,
6511            message_fields: Some(FunctionDescriptor::FIELDS),
6512        };
6513    }
6514    impl MessageFields for GetFunctionResponse {
6515        const FIELDS: &'static [&'static MessageField] = &[Self::FUNCTION_FIELD];
6516    }
6517    impl GetFunctionResponse {
6518        pub fn path_builder() -> GetFunctionResponseFieldPathBuilder {
6519            GetFunctionResponseFieldPathBuilder::new()
6520        }
6521    }
6522    pub struct GetFunctionResponseFieldPathBuilder {
6523        path: Vec<&'static str>,
6524    }
6525    impl GetFunctionResponseFieldPathBuilder {
6526        #[allow(clippy::new_without_default)]
6527        pub fn new() -> Self {
6528            Self { path: Default::default() }
6529        }
6530        #[doc(hidden)]
6531        pub fn new_with_base(base: Vec<&'static str>) -> Self {
6532            Self { path: base }
6533        }
6534        pub fn finish(self) -> String {
6535            self.path.join(".")
6536        }
6537        pub fn function(mut self) -> FunctionDescriptorFieldPathBuilder {
6538            self.path.push(GetFunctionResponse::FUNCTION_FIELD.name);
6539            FunctionDescriptorFieldPathBuilder::new_with_base(self.path)
6540        }
6541    }
6542    impl ListPackageVersionsRequest {
6543        pub const PACKAGE_ID_FIELD: &'static MessageField = &MessageField {
6544            name: "package_id",
6545            json_name: "packageId",
6546            number: 1i32,
6547            message_fields: None,
6548        };
6549        pub const PAGE_SIZE_FIELD: &'static MessageField = &MessageField {
6550            name: "page_size",
6551            json_name: "pageSize",
6552            number: 2i32,
6553            message_fields: None,
6554        };
6555        pub const PAGE_TOKEN_FIELD: &'static MessageField = &MessageField {
6556            name: "page_token",
6557            json_name: "pageToken",
6558            number: 3i32,
6559            message_fields: None,
6560        };
6561        pub const OPTIONS_FIELD: &'static MessageField = &MessageField {
6562            name: "options",
6563            json_name: "options",
6564            number: 5i32,
6565            message_fields: Some(QueryOptions::FIELDS),
6566        };
6567        pub const START_VERSION_FIELD: &'static MessageField = &MessageField {
6568            name: "start_version",
6569            json_name: "startVersion",
6570            number: 6i32,
6571            message_fields: None,
6572        };
6573        pub const END_VERSION_FIELD: &'static MessageField = &MessageField {
6574            name: "end_version",
6575            json_name: "endVersion",
6576            number: 7i32,
6577            message_fields: None,
6578        };
6579        pub const START_CHECKPOINT_FIELD: &'static MessageField = &MessageField {
6580            name: "start_checkpoint",
6581            json_name: "startCheckpoint",
6582            number: 8i32,
6583            message_fields: None,
6584        };
6585        pub const END_CHECKPOINT_FIELD: &'static MessageField = &MessageField {
6586            name: "end_checkpoint",
6587            json_name: "endCheckpoint",
6588            number: 9i32,
6589            message_fields: None,
6590        };
6591    }
6592    impl MessageFields for ListPackageVersionsRequest {
6593        const FIELDS: &'static [&'static MessageField] = &[
6594            Self::PACKAGE_ID_FIELD,
6595            Self::PAGE_SIZE_FIELD,
6596            Self::PAGE_TOKEN_FIELD,
6597            Self::OPTIONS_FIELD,
6598            Self::START_VERSION_FIELD,
6599            Self::END_VERSION_FIELD,
6600            Self::START_CHECKPOINT_FIELD,
6601            Self::END_CHECKPOINT_FIELD,
6602        ];
6603    }
6604    impl ListPackageVersionsRequest {
6605        pub fn path_builder() -> ListPackageVersionsRequestFieldPathBuilder {
6606            ListPackageVersionsRequestFieldPathBuilder::new()
6607        }
6608    }
6609    pub struct ListPackageVersionsRequestFieldPathBuilder {
6610        path: Vec<&'static str>,
6611    }
6612    impl ListPackageVersionsRequestFieldPathBuilder {
6613        #[allow(clippy::new_without_default)]
6614        pub fn new() -> Self {
6615            Self { path: Default::default() }
6616        }
6617        #[doc(hidden)]
6618        pub fn new_with_base(base: Vec<&'static str>) -> Self {
6619            Self { path: base }
6620        }
6621        pub fn finish(self) -> String {
6622            self.path.join(".")
6623        }
6624        pub fn package_id(mut self) -> String {
6625            self.path.push(ListPackageVersionsRequest::PACKAGE_ID_FIELD.name);
6626            self.finish()
6627        }
6628        pub fn page_size(mut self) -> String {
6629            self.path.push(ListPackageVersionsRequest::PAGE_SIZE_FIELD.name);
6630            self.finish()
6631        }
6632        pub fn page_token(mut self) -> String {
6633            self.path.push(ListPackageVersionsRequest::PAGE_TOKEN_FIELD.name);
6634            self.finish()
6635        }
6636        pub fn options(mut self) -> QueryOptionsFieldPathBuilder {
6637            self.path.push(ListPackageVersionsRequest::OPTIONS_FIELD.name);
6638            QueryOptionsFieldPathBuilder::new_with_base(self.path)
6639        }
6640        pub fn start_version(mut self) -> String {
6641            self.path.push(ListPackageVersionsRequest::START_VERSION_FIELD.name);
6642            self.finish()
6643        }
6644        pub fn end_version(mut self) -> String {
6645            self.path.push(ListPackageVersionsRequest::END_VERSION_FIELD.name);
6646            self.finish()
6647        }
6648        pub fn start_checkpoint(mut self) -> String {
6649            self.path.push(ListPackageVersionsRequest::START_CHECKPOINT_FIELD.name);
6650            self.finish()
6651        }
6652        pub fn end_checkpoint(mut self) -> String {
6653            self.path.push(ListPackageVersionsRequest::END_CHECKPOINT_FIELD.name);
6654            self.finish()
6655        }
6656    }
6657    impl ListPackageVersionsResponse {
6658        pub const VERSIONS_FIELD: &'static MessageField = &MessageField {
6659            name: "versions",
6660            json_name: "versions",
6661            number: 1i32,
6662            message_fields: Some(PackageVersion::FIELDS),
6663        };
6664        pub const NEXT_PAGE_TOKEN_FIELD: &'static MessageField = &MessageField {
6665            name: "next_page_token",
6666            json_name: "nextPageToken",
6667            number: 2i32,
6668            message_fields: None,
6669        };
6670        pub const END_FIELD: &'static MessageField = &MessageField {
6671            name: "end",
6672            json_name: "end",
6673            number: 3i32,
6674            message_fields: Some(QueryEnd::FIELDS),
6675        };
6676    }
6677    impl MessageFields for ListPackageVersionsResponse {
6678        const FIELDS: &'static [&'static MessageField] = &[
6679            Self::VERSIONS_FIELD,
6680            Self::NEXT_PAGE_TOKEN_FIELD,
6681            Self::END_FIELD,
6682        ];
6683    }
6684    impl ListPackageVersionsResponse {
6685        pub fn path_builder() -> ListPackageVersionsResponseFieldPathBuilder {
6686            ListPackageVersionsResponseFieldPathBuilder::new()
6687        }
6688    }
6689    pub struct ListPackageVersionsResponseFieldPathBuilder {
6690        path: Vec<&'static str>,
6691    }
6692    impl ListPackageVersionsResponseFieldPathBuilder {
6693        #[allow(clippy::new_without_default)]
6694        pub fn new() -> Self {
6695            Self { path: Default::default() }
6696        }
6697        #[doc(hidden)]
6698        pub fn new_with_base(base: Vec<&'static str>) -> Self {
6699            Self { path: base }
6700        }
6701        pub fn finish(self) -> String {
6702            self.path.join(".")
6703        }
6704        pub fn versions(mut self) -> PackageVersionFieldPathBuilder {
6705            self.path.push(ListPackageVersionsResponse::VERSIONS_FIELD.name);
6706            PackageVersionFieldPathBuilder::new_with_base(self.path)
6707        }
6708        pub fn next_page_token(mut self) -> String {
6709            self.path.push(ListPackageVersionsResponse::NEXT_PAGE_TOKEN_FIELD.name);
6710            self.finish()
6711        }
6712        pub fn end(mut self) -> QueryEndFieldPathBuilder {
6713            self.path.push(ListPackageVersionsResponse::END_FIELD.name);
6714            QueryEndFieldPathBuilder::new_with_base(self.path)
6715        }
6716    }
6717    impl ListSystemPackagesRequest {
6718        pub const AT_CHECKPOINT_FIELD: &'static MessageField = &MessageField {
6719            name: "at_checkpoint",
6720            json_name: "atCheckpoint",
6721            number: 1i32,
6722            message_fields: None,
6723        };
6724    }
6725    impl MessageFields for ListSystemPackagesRequest {
6726        const FIELDS: &'static [&'static MessageField] = &[Self::AT_CHECKPOINT_FIELD];
6727    }
6728    impl ListSystemPackagesRequest {
6729        pub fn path_builder() -> ListSystemPackagesRequestFieldPathBuilder {
6730            ListSystemPackagesRequestFieldPathBuilder::new()
6731        }
6732    }
6733    pub struct ListSystemPackagesRequestFieldPathBuilder {
6734        path: Vec<&'static str>,
6735    }
6736    impl ListSystemPackagesRequestFieldPathBuilder {
6737        #[allow(clippy::new_without_default)]
6738        pub fn new() -> Self {
6739            Self { path: Default::default() }
6740        }
6741        #[doc(hidden)]
6742        pub fn new_with_base(base: Vec<&'static str>) -> Self {
6743            Self { path: base }
6744        }
6745        pub fn finish(self) -> String {
6746            self.path.join(".")
6747        }
6748        pub fn at_checkpoint(mut self) -> String {
6749            self.path.push(ListSystemPackagesRequest::AT_CHECKPOINT_FIELD.name);
6750            self.finish()
6751        }
6752    }
6753    impl ListSystemPackagesResponse {
6754        pub const SYSTEM_PACKAGES_FIELD: &'static MessageField = &MessageField {
6755            name: "system_packages",
6756            json_name: "systemPackages",
6757            number: 1i32,
6758            message_fields: Some(PackageVersion::FIELDS),
6759        };
6760    }
6761    impl MessageFields for ListSystemPackagesResponse {
6762        const FIELDS: &'static [&'static MessageField] = &[Self::SYSTEM_PACKAGES_FIELD];
6763    }
6764    impl ListSystemPackagesResponse {
6765        pub fn path_builder() -> ListSystemPackagesResponseFieldPathBuilder {
6766            ListSystemPackagesResponseFieldPathBuilder::new()
6767        }
6768    }
6769    pub struct ListSystemPackagesResponseFieldPathBuilder {
6770        path: Vec<&'static str>,
6771    }
6772    impl ListSystemPackagesResponseFieldPathBuilder {
6773        #[allow(clippy::new_without_default)]
6774        pub fn new() -> Self {
6775            Self { path: Default::default() }
6776        }
6777        #[doc(hidden)]
6778        pub fn new_with_base(base: Vec<&'static str>) -> Self {
6779            Self { path: base }
6780        }
6781        pub fn finish(self) -> String {
6782            self.path.join(".")
6783        }
6784        pub fn system_packages(mut self) -> PackageVersionFieldPathBuilder {
6785            self.path.push(ListSystemPackagesResponse::SYSTEM_PACKAGES_FIELD.name);
6786            PackageVersionFieldPathBuilder::new_with_base(self.path)
6787        }
6788    }
6789    impl PackageVersion {
6790        pub const PACKAGE_ID_FIELD: &'static MessageField = &MessageField {
6791            name: "package_id",
6792            json_name: "packageId",
6793            number: 1i32,
6794            message_fields: None,
6795        };
6796        pub const VERSION_FIELD: &'static MessageField = &MessageField {
6797            name: "version",
6798            json_name: "version",
6799            number: 2i32,
6800            message_fields: None,
6801        };
6802        pub const CHECKPOINT_FIELD: &'static MessageField = &MessageField {
6803            name: "checkpoint",
6804            json_name: "checkpoint",
6805            number: 3i32,
6806            message_fields: None,
6807        };
6808        pub const CURSOR_FIELD: &'static MessageField = &MessageField {
6809            name: "cursor",
6810            json_name: "cursor",
6811            number: 4i32,
6812            message_fields: None,
6813        };
6814        pub const ORIGINAL_ID_FIELD: &'static MessageField = &MessageField {
6815            name: "original_id",
6816            json_name: "originalId",
6817            number: 5i32,
6818            message_fields: None,
6819        };
6820    }
6821    impl MessageFields for PackageVersion {
6822        const FIELDS: &'static [&'static MessageField] = &[
6823            Self::PACKAGE_ID_FIELD,
6824            Self::VERSION_FIELD,
6825            Self::CHECKPOINT_FIELD,
6826            Self::CURSOR_FIELD,
6827            Self::ORIGINAL_ID_FIELD,
6828        ];
6829    }
6830    impl PackageVersion {
6831        pub fn path_builder() -> PackageVersionFieldPathBuilder {
6832            PackageVersionFieldPathBuilder::new()
6833        }
6834    }
6835    pub struct PackageVersionFieldPathBuilder {
6836        path: Vec<&'static str>,
6837    }
6838    impl PackageVersionFieldPathBuilder {
6839        #[allow(clippy::new_without_default)]
6840        pub fn new() -> Self {
6841            Self { path: Default::default() }
6842        }
6843        #[doc(hidden)]
6844        pub fn new_with_base(base: Vec<&'static str>) -> Self {
6845            Self { path: base }
6846        }
6847        pub fn finish(self) -> String {
6848            self.path.join(".")
6849        }
6850        pub fn package_id(mut self) -> String {
6851            self.path.push(PackageVersion::PACKAGE_ID_FIELD.name);
6852            self.finish()
6853        }
6854        pub fn version(mut self) -> String {
6855            self.path.push(PackageVersion::VERSION_FIELD.name);
6856            self.finish()
6857        }
6858        pub fn checkpoint(mut self) -> String {
6859            self.path.push(PackageVersion::CHECKPOINT_FIELD.name);
6860            self.finish()
6861        }
6862        pub fn cursor(mut self) -> String {
6863            self.path.push(PackageVersion::CURSOR_FIELD.name);
6864            self.finish()
6865        }
6866        pub fn original_id(mut self) -> String {
6867            self.path.push(PackageVersion::ORIGINAL_ID_FIELD.name);
6868            self.finish()
6869        }
6870    }
6871    impl LookupNameRequest {
6872        pub const NAME_FIELD: &'static MessageField = &MessageField {
6873            name: "name",
6874            json_name: "name",
6875            number: 1i32,
6876            message_fields: None,
6877        };
6878    }
6879    impl MessageFields for LookupNameRequest {
6880        const FIELDS: &'static [&'static MessageField] = &[Self::NAME_FIELD];
6881    }
6882    impl LookupNameRequest {
6883        pub fn path_builder() -> LookupNameRequestFieldPathBuilder {
6884            LookupNameRequestFieldPathBuilder::new()
6885        }
6886    }
6887    pub struct LookupNameRequestFieldPathBuilder {
6888        path: Vec<&'static str>,
6889    }
6890    impl LookupNameRequestFieldPathBuilder {
6891        #[allow(clippy::new_without_default)]
6892        pub fn new() -> Self {
6893            Self { path: Default::default() }
6894        }
6895        #[doc(hidden)]
6896        pub fn new_with_base(base: Vec<&'static str>) -> Self {
6897            Self { path: base }
6898        }
6899        pub fn finish(self) -> String {
6900            self.path.join(".")
6901        }
6902        pub fn name(mut self) -> String {
6903            self.path.push(LookupNameRequest::NAME_FIELD.name);
6904            self.finish()
6905        }
6906    }
6907    impl LookupNameResponse {
6908        pub const RECORD_FIELD: &'static MessageField = &MessageField {
6909            name: "record",
6910            json_name: "record",
6911            number: 1i32,
6912            message_fields: Some(NameRecord::FIELDS),
6913        };
6914    }
6915    impl MessageFields for LookupNameResponse {
6916        const FIELDS: &'static [&'static MessageField] = &[Self::RECORD_FIELD];
6917    }
6918    impl LookupNameResponse {
6919        pub fn path_builder() -> LookupNameResponseFieldPathBuilder {
6920            LookupNameResponseFieldPathBuilder::new()
6921        }
6922    }
6923    pub struct LookupNameResponseFieldPathBuilder {
6924        path: Vec<&'static str>,
6925    }
6926    impl LookupNameResponseFieldPathBuilder {
6927        #[allow(clippy::new_without_default)]
6928        pub fn new() -> Self {
6929            Self { path: Default::default() }
6930        }
6931        #[doc(hidden)]
6932        pub fn new_with_base(base: Vec<&'static str>) -> Self {
6933            Self { path: base }
6934        }
6935        pub fn finish(self) -> String {
6936            self.path.join(".")
6937        }
6938        pub fn record(mut self) -> NameRecordFieldPathBuilder {
6939            self.path.push(LookupNameResponse::RECORD_FIELD.name);
6940            NameRecordFieldPathBuilder::new_with_base(self.path)
6941        }
6942    }
6943    impl ReverseLookupNameRequest {
6944        pub const ADDRESS_FIELD: &'static MessageField = &MessageField {
6945            name: "address",
6946            json_name: "address",
6947            number: 1i32,
6948            message_fields: None,
6949        };
6950    }
6951    impl MessageFields for ReverseLookupNameRequest {
6952        const FIELDS: &'static [&'static MessageField] = &[Self::ADDRESS_FIELD];
6953    }
6954    impl ReverseLookupNameRequest {
6955        pub fn path_builder() -> ReverseLookupNameRequestFieldPathBuilder {
6956            ReverseLookupNameRequestFieldPathBuilder::new()
6957        }
6958    }
6959    pub struct ReverseLookupNameRequestFieldPathBuilder {
6960        path: Vec<&'static str>,
6961    }
6962    impl ReverseLookupNameRequestFieldPathBuilder {
6963        #[allow(clippy::new_without_default)]
6964        pub fn new() -> Self {
6965            Self { path: Default::default() }
6966        }
6967        #[doc(hidden)]
6968        pub fn new_with_base(base: Vec<&'static str>) -> Self {
6969            Self { path: base }
6970        }
6971        pub fn finish(self) -> String {
6972            self.path.join(".")
6973        }
6974        pub fn address(mut self) -> String {
6975            self.path.push(ReverseLookupNameRequest::ADDRESS_FIELD.name);
6976            self.finish()
6977        }
6978    }
6979    impl ReverseLookupNameResponse {
6980        pub const RECORD_FIELD: &'static MessageField = &MessageField {
6981            name: "record",
6982            json_name: "record",
6983            number: 1i32,
6984            message_fields: Some(NameRecord::FIELDS),
6985        };
6986    }
6987    impl MessageFields for ReverseLookupNameResponse {
6988        const FIELDS: &'static [&'static MessageField] = &[Self::RECORD_FIELD];
6989    }
6990    impl ReverseLookupNameResponse {
6991        pub fn path_builder() -> ReverseLookupNameResponseFieldPathBuilder {
6992            ReverseLookupNameResponseFieldPathBuilder::new()
6993        }
6994    }
6995    pub struct ReverseLookupNameResponseFieldPathBuilder {
6996        path: Vec<&'static str>,
6997    }
6998    impl ReverseLookupNameResponseFieldPathBuilder {
6999        #[allow(clippy::new_without_default)]
7000        pub fn new() -> Self {
7001            Self { path: Default::default() }
7002        }
7003        #[doc(hidden)]
7004        pub fn new_with_base(base: Vec<&'static str>) -> Self {
7005            Self { path: base }
7006        }
7007        pub fn finish(self) -> String {
7008            self.path.join(".")
7009        }
7010        pub fn record(mut self) -> NameRecordFieldPathBuilder {
7011            self.path.push(ReverseLookupNameResponse::RECORD_FIELD.name);
7012            NameRecordFieldPathBuilder::new_with_base(self.path)
7013        }
7014    }
7015    impl NameRecord {
7016        pub const ID_FIELD: &'static MessageField = &MessageField {
7017            name: "id",
7018            json_name: "id",
7019            number: 1i32,
7020            message_fields: None,
7021        };
7022        pub const NAME_FIELD: &'static MessageField = &MessageField {
7023            name: "name",
7024            json_name: "name",
7025            number: 2i32,
7026            message_fields: None,
7027        };
7028        pub const REGISTRATION_NFT_ID_FIELD: &'static MessageField = &MessageField {
7029            name: "registration_nft_id",
7030            json_name: "registrationNftId",
7031            number: 3i32,
7032            message_fields: None,
7033        };
7034        pub const EXPIRATION_TIMESTAMP_FIELD: &'static MessageField = &MessageField {
7035            name: "expiration_timestamp",
7036            json_name: "expirationTimestamp",
7037            number: 4i32,
7038            message_fields: None,
7039        };
7040        pub const TARGET_ADDRESS_FIELD: &'static MessageField = &MessageField {
7041            name: "target_address",
7042            json_name: "targetAddress",
7043            number: 5i32,
7044            message_fields: None,
7045        };
7046        pub const DATA_FIELD: &'static MessageField = &MessageField {
7047            name: "data",
7048            json_name: "data",
7049            number: 6i32,
7050            message_fields: None,
7051        };
7052    }
7053    impl MessageFields for NameRecord {
7054        const FIELDS: &'static [&'static MessageField] = &[
7055            Self::ID_FIELD,
7056            Self::NAME_FIELD,
7057            Self::REGISTRATION_NFT_ID_FIELD,
7058            Self::EXPIRATION_TIMESTAMP_FIELD,
7059            Self::TARGET_ADDRESS_FIELD,
7060            Self::DATA_FIELD,
7061        ];
7062    }
7063    impl NameRecord {
7064        pub fn path_builder() -> NameRecordFieldPathBuilder {
7065            NameRecordFieldPathBuilder::new()
7066        }
7067    }
7068    pub struct NameRecordFieldPathBuilder {
7069        path: Vec<&'static str>,
7070    }
7071    impl NameRecordFieldPathBuilder {
7072        #[allow(clippy::new_without_default)]
7073        pub fn new() -> Self {
7074            Self { path: Default::default() }
7075        }
7076        #[doc(hidden)]
7077        pub fn new_with_base(base: Vec<&'static str>) -> Self {
7078            Self { path: base }
7079        }
7080        pub fn finish(self) -> String {
7081            self.path.join(".")
7082        }
7083        pub fn id(mut self) -> String {
7084            self.path.push(NameRecord::ID_FIELD.name);
7085            self.finish()
7086        }
7087        pub fn name(mut self) -> String {
7088            self.path.push(NameRecord::NAME_FIELD.name);
7089            self.finish()
7090        }
7091        pub fn registration_nft_id(mut self) -> String {
7092            self.path.push(NameRecord::REGISTRATION_NFT_ID_FIELD.name);
7093            self.finish()
7094        }
7095        pub fn expiration_timestamp(mut self) -> String {
7096            self.path.push(NameRecord::EXPIRATION_TIMESTAMP_FIELD.name);
7097            self.finish()
7098        }
7099        pub fn target_address(mut self) -> String {
7100            self.path.push(NameRecord::TARGET_ADDRESS_FIELD.name);
7101            self.finish()
7102        }
7103        pub fn data(mut self) -> String {
7104            self.path.push(NameRecord::DATA_FIELD.name);
7105            self.finish()
7106        }
7107    }
7108    impl Object {
7109        pub const BCS_FIELD: &'static MessageField = &MessageField {
7110            name: "bcs",
7111            json_name: "bcs",
7112            number: 1i32,
7113            message_fields: Some(Bcs::FIELDS),
7114        };
7115        pub const OBJECT_ID_FIELD: &'static MessageField = &MessageField {
7116            name: "object_id",
7117            json_name: "objectId",
7118            number: 2i32,
7119            message_fields: None,
7120        };
7121        pub const VERSION_FIELD: &'static MessageField = &MessageField {
7122            name: "version",
7123            json_name: "version",
7124            number: 3i32,
7125            message_fields: None,
7126        };
7127        pub const DIGEST_FIELD: &'static MessageField = &MessageField {
7128            name: "digest",
7129            json_name: "digest",
7130            number: 4i32,
7131            message_fields: None,
7132        };
7133        pub const OWNER_FIELD: &'static MessageField = &MessageField {
7134            name: "owner",
7135            json_name: "owner",
7136            number: 5i32,
7137            message_fields: Some(Owner::FIELDS),
7138        };
7139        pub const OBJECT_TYPE_FIELD: &'static MessageField = &MessageField {
7140            name: "object_type",
7141            json_name: "objectType",
7142            number: 6i32,
7143            message_fields: None,
7144        };
7145        pub const HAS_PUBLIC_TRANSFER_FIELD: &'static MessageField = &MessageField {
7146            name: "has_public_transfer",
7147            json_name: "hasPublicTransfer",
7148            number: 7i32,
7149            message_fields: None,
7150        };
7151        pub const CONTENTS_FIELD: &'static MessageField = &MessageField {
7152            name: "contents",
7153            json_name: "contents",
7154            number: 8i32,
7155            message_fields: Some(Bcs::FIELDS),
7156        };
7157        pub const PACKAGE_FIELD: &'static MessageField = &MessageField {
7158            name: "package",
7159            json_name: "package",
7160            number: 9i32,
7161            message_fields: Some(Package::FIELDS),
7162        };
7163        pub const PREVIOUS_TRANSACTION_FIELD: &'static MessageField = &MessageField {
7164            name: "previous_transaction",
7165            json_name: "previousTransaction",
7166            number: 10i32,
7167            message_fields: None,
7168        };
7169        pub const STORAGE_REBATE_FIELD: &'static MessageField = &MessageField {
7170            name: "storage_rebate",
7171            json_name: "storageRebate",
7172            number: 11i32,
7173            message_fields: None,
7174        };
7175        pub const JSON_FIELD: &'static MessageField = &MessageField {
7176            name: "json",
7177            json_name: "json",
7178            number: 100i32,
7179            message_fields: None,
7180        };
7181        pub const BALANCE_FIELD: &'static MessageField = &MessageField {
7182            name: "balance",
7183            json_name: "balance",
7184            number: 101i32,
7185            message_fields: None,
7186        };
7187        pub const DISPLAY_FIELD: &'static MessageField = &MessageField {
7188            name: "display",
7189            json_name: "display",
7190            number: 102i32,
7191            message_fields: Some(Display::FIELDS),
7192        };
7193    }
7194    impl MessageFields for Object {
7195        const FIELDS: &'static [&'static MessageField] = &[
7196            Self::BCS_FIELD,
7197            Self::OBJECT_ID_FIELD,
7198            Self::VERSION_FIELD,
7199            Self::DIGEST_FIELD,
7200            Self::OWNER_FIELD,
7201            Self::OBJECT_TYPE_FIELD,
7202            Self::HAS_PUBLIC_TRANSFER_FIELD,
7203            Self::CONTENTS_FIELD,
7204            Self::PACKAGE_FIELD,
7205            Self::PREVIOUS_TRANSACTION_FIELD,
7206            Self::STORAGE_REBATE_FIELD,
7207            Self::JSON_FIELD,
7208            Self::BALANCE_FIELD,
7209            Self::DISPLAY_FIELD,
7210        ];
7211    }
7212    impl Object {
7213        pub fn path_builder() -> ObjectFieldPathBuilder {
7214            ObjectFieldPathBuilder::new()
7215        }
7216    }
7217    pub struct ObjectFieldPathBuilder {
7218        path: Vec<&'static str>,
7219    }
7220    impl ObjectFieldPathBuilder {
7221        #[allow(clippy::new_without_default)]
7222        pub fn new() -> Self {
7223            Self { path: Default::default() }
7224        }
7225        #[doc(hidden)]
7226        pub fn new_with_base(base: Vec<&'static str>) -> Self {
7227            Self { path: base }
7228        }
7229        pub fn finish(self) -> String {
7230            self.path.join(".")
7231        }
7232        pub fn bcs(mut self) -> BcsFieldPathBuilder {
7233            self.path.push(Object::BCS_FIELD.name);
7234            BcsFieldPathBuilder::new_with_base(self.path)
7235        }
7236        pub fn object_id(mut self) -> String {
7237            self.path.push(Object::OBJECT_ID_FIELD.name);
7238            self.finish()
7239        }
7240        pub fn version(mut self) -> String {
7241            self.path.push(Object::VERSION_FIELD.name);
7242            self.finish()
7243        }
7244        pub fn digest(mut self) -> String {
7245            self.path.push(Object::DIGEST_FIELD.name);
7246            self.finish()
7247        }
7248        pub fn owner(mut self) -> OwnerFieldPathBuilder {
7249            self.path.push(Object::OWNER_FIELD.name);
7250            OwnerFieldPathBuilder::new_with_base(self.path)
7251        }
7252        pub fn object_type(mut self) -> String {
7253            self.path.push(Object::OBJECT_TYPE_FIELD.name);
7254            self.finish()
7255        }
7256        pub fn has_public_transfer(mut self) -> String {
7257            self.path.push(Object::HAS_PUBLIC_TRANSFER_FIELD.name);
7258            self.finish()
7259        }
7260        pub fn contents(mut self) -> BcsFieldPathBuilder {
7261            self.path.push(Object::CONTENTS_FIELD.name);
7262            BcsFieldPathBuilder::new_with_base(self.path)
7263        }
7264        pub fn package(mut self) -> PackageFieldPathBuilder {
7265            self.path.push(Object::PACKAGE_FIELD.name);
7266            PackageFieldPathBuilder::new_with_base(self.path)
7267        }
7268        pub fn previous_transaction(mut self) -> String {
7269            self.path.push(Object::PREVIOUS_TRANSACTION_FIELD.name);
7270            self.finish()
7271        }
7272        pub fn storage_rebate(mut self) -> String {
7273            self.path.push(Object::STORAGE_REBATE_FIELD.name);
7274            self.finish()
7275        }
7276        pub fn json(mut self) -> String {
7277            self.path.push(Object::JSON_FIELD.name);
7278            self.finish()
7279        }
7280        pub fn balance(mut self) -> String {
7281            self.path.push(Object::BALANCE_FIELD.name);
7282            self.finish()
7283        }
7284        pub fn display(mut self) -> DisplayFieldPathBuilder {
7285            self.path.push(Object::DISPLAY_FIELD.name);
7286            DisplayFieldPathBuilder::new_with_base(self.path)
7287        }
7288    }
7289    impl ObjectSet {
7290        pub const OBJECTS_FIELD: &'static MessageField = &MessageField {
7291            name: "objects",
7292            json_name: "objects",
7293            number: 1i32,
7294            message_fields: Some(Object::FIELDS),
7295        };
7296    }
7297    impl MessageFields for ObjectSet {
7298        const FIELDS: &'static [&'static MessageField] = &[Self::OBJECTS_FIELD];
7299    }
7300    impl ObjectSet {
7301        pub fn path_builder() -> ObjectSetFieldPathBuilder {
7302            ObjectSetFieldPathBuilder::new()
7303        }
7304    }
7305    pub struct ObjectSetFieldPathBuilder {
7306        path: Vec<&'static str>,
7307    }
7308    impl ObjectSetFieldPathBuilder {
7309        #[allow(clippy::new_without_default)]
7310        pub fn new() -> Self {
7311            Self { path: Default::default() }
7312        }
7313        #[doc(hidden)]
7314        pub fn new_with_base(base: Vec<&'static str>) -> Self {
7315            Self { path: base }
7316        }
7317        pub fn finish(self) -> String {
7318            self.path.join(".")
7319        }
7320        pub fn objects(mut self) -> ObjectFieldPathBuilder {
7321            self.path.push(ObjectSet::OBJECTS_FIELD.name);
7322            ObjectFieldPathBuilder::new_with_base(self.path)
7323        }
7324    }
7325    impl Display {
7326        pub const OUTPUT_FIELD: &'static MessageField = &MessageField {
7327            name: "output",
7328            json_name: "output",
7329            number: 1i32,
7330            message_fields: None,
7331        };
7332        pub const ERRORS_FIELD: &'static MessageField = &MessageField {
7333            name: "errors",
7334            json_name: "errors",
7335            number: 2i32,
7336            message_fields: None,
7337        };
7338    }
7339    impl MessageFields for Display {
7340        const FIELDS: &'static [&'static MessageField] = &[
7341            Self::OUTPUT_FIELD,
7342            Self::ERRORS_FIELD,
7343        ];
7344    }
7345    impl Display {
7346        pub fn path_builder() -> DisplayFieldPathBuilder {
7347            DisplayFieldPathBuilder::new()
7348        }
7349    }
7350    pub struct DisplayFieldPathBuilder {
7351        path: Vec<&'static str>,
7352    }
7353    impl DisplayFieldPathBuilder {
7354        #[allow(clippy::new_without_default)]
7355        pub fn new() -> Self {
7356            Self { path: Default::default() }
7357        }
7358        #[doc(hidden)]
7359        pub fn new_with_base(base: Vec<&'static str>) -> Self {
7360            Self { path: base }
7361        }
7362        pub fn finish(self) -> String {
7363            self.path.join(".")
7364        }
7365        pub fn output(mut self) -> String {
7366            self.path.push(Display::OUTPUT_FIELD.name);
7367            self.finish()
7368        }
7369        pub fn errors(mut self) -> String {
7370            self.path.push(Display::ERRORS_FIELD.name);
7371            self.finish()
7372        }
7373    }
7374    impl ObjectReference {
7375        pub const OBJECT_ID_FIELD: &'static MessageField = &MessageField {
7376            name: "object_id",
7377            json_name: "objectId",
7378            number: 1i32,
7379            message_fields: None,
7380        };
7381        pub const VERSION_FIELD: &'static MessageField = &MessageField {
7382            name: "version",
7383            json_name: "version",
7384            number: 2i32,
7385            message_fields: None,
7386        };
7387        pub const DIGEST_FIELD: &'static MessageField = &MessageField {
7388            name: "digest",
7389            json_name: "digest",
7390            number: 3i32,
7391            message_fields: None,
7392        };
7393    }
7394    impl MessageFields for ObjectReference {
7395        const FIELDS: &'static [&'static MessageField] = &[
7396            Self::OBJECT_ID_FIELD,
7397            Self::VERSION_FIELD,
7398            Self::DIGEST_FIELD,
7399        ];
7400    }
7401    impl ObjectReference {
7402        pub fn path_builder() -> ObjectReferenceFieldPathBuilder {
7403            ObjectReferenceFieldPathBuilder::new()
7404        }
7405    }
7406    pub struct ObjectReferenceFieldPathBuilder {
7407        path: Vec<&'static str>,
7408    }
7409    impl ObjectReferenceFieldPathBuilder {
7410        #[allow(clippy::new_without_default)]
7411        pub fn new() -> Self {
7412            Self { path: Default::default() }
7413        }
7414        #[doc(hidden)]
7415        pub fn new_with_base(base: Vec<&'static str>) -> Self {
7416            Self { path: base }
7417        }
7418        pub fn finish(self) -> String {
7419            self.path.join(".")
7420        }
7421        pub fn object_id(mut self) -> String {
7422            self.path.push(ObjectReference::OBJECT_ID_FIELD.name);
7423            self.finish()
7424        }
7425        pub fn version(mut self) -> String {
7426            self.path.push(ObjectReference::VERSION_FIELD.name);
7427            self.finish()
7428        }
7429        pub fn digest(mut self) -> String {
7430            self.path.push(ObjectReference::DIGEST_FIELD.name);
7431            self.finish()
7432        }
7433    }
7434    impl Owner {
7435        pub const KIND_FIELD: &'static MessageField = &MessageField {
7436            name: "kind",
7437            json_name: "kind",
7438            number: 1i32,
7439            message_fields: None,
7440        };
7441        pub const ADDRESS_FIELD: &'static MessageField = &MessageField {
7442            name: "address",
7443            json_name: "address",
7444            number: 2i32,
7445            message_fields: None,
7446        };
7447        pub const VERSION_FIELD: &'static MessageField = &MessageField {
7448            name: "version",
7449            json_name: "version",
7450            number: 3i32,
7451            message_fields: None,
7452        };
7453    }
7454    impl MessageFields for Owner {
7455        const FIELDS: &'static [&'static MessageField] = &[
7456            Self::KIND_FIELD,
7457            Self::ADDRESS_FIELD,
7458            Self::VERSION_FIELD,
7459        ];
7460    }
7461    impl Owner {
7462        pub fn path_builder() -> OwnerFieldPathBuilder {
7463            OwnerFieldPathBuilder::new()
7464        }
7465    }
7466    pub struct OwnerFieldPathBuilder {
7467        path: Vec<&'static str>,
7468    }
7469    impl OwnerFieldPathBuilder {
7470        #[allow(clippy::new_without_default)]
7471        pub fn new() -> Self {
7472            Self { path: Default::default() }
7473        }
7474        #[doc(hidden)]
7475        pub fn new_with_base(base: Vec<&'static str>) -> Self {
7476            Self { path: base }
7477        }
7478        pub fn finish(self) -> String {
7479            self.path.join(".")
7480        }
7481        pub fn kind(mut self) -> String {
7482            self.path.push(Owner::KIND_FIELD.name);
7483            self.finish()
7484        }
7485        pub fn address(mut self) -> String {
7486            self.path.push(Owner::ADDRESS_FIELD.name);
7487            self.finish()
7488        }
7489        pub fn version(mut self) -> String {
7490            self.path.push(Owner::VERSION_FIELD.name);
7491            self.finish()
7492        }
7493    }
7494    impl ProtocolConfig {
7495        pub const PROTOCOL_VERSION_FIELD: &'static MessageField = &MessageField {
7496            name: "protocol_version",
7497            json_name: "protocolVersion",
7498            number: 1i32,
7499            message_fields: None,
7500        };
7501        pub const FEATURE_FLAGS_FIELD: &'static MessageField = &MessageField {
7502            name: "feature_flags",
7503            json_name: "featureFlags",
7504            number: 2i32,
7505            message_fields: None,
7506        };
7507        pub const ATTRIBUTES_FIELD: &'static MessageField = &MessageField {
7508            name: "attributes",
7509            json_name: "attributes",
7510            number: 3i32,
7511            message_fields: None,
7512        };
7513        pub const CONFIGS_FIELD: &'static MessageField = &MessageField {
7514            name: "configs",
7515            json_name: "configs",
7516            number: 4i32,
7517            message_fields: None,
7518        };
7519    }
7520    impl MessageFields for ProtocolConfig {
7521        const FIELDS: &'static [&'static MessageField] = &[
7522            Self::PROTOCOL_VERSION_FIELD,
7523            Self::FEATURE_FLAGS_FIELD,
7524            Self::ATTRIBUTES_FIELD,
7525            Self::CONFIGS_FIELD,
7526        ];
7527    }
7528    impl ProtocolConfig {
7529        pub fn path_builder() -> ProtocolConfigFieldPathBuilder {
7530            ProtocolConfigFieldPathBuilder::new()
7531        }
7532    }
7533    pub struct ProtocolConfigFieldPathBuilder {
7534        path: Vec<&'static str>,
7535    }
7536    impl ProtocolConfigFieldPathBuilder {
7537        #[allow(clippy::new_without_default)]
7538        pub fn new() -> Self {
7539            Self { path: Default::default() }
7540        }
7541        #[doc(hidden)]
7542        pub fn new_with_base(base: Vec<&'static str>) -> Self {
7543            Self { path: base }
7544        }
7545        pub fn finish(self) -> String {
7546            self.path.join(".")
7547        }
7548        pub fn protocol_version(mut self) -> String {
7549            self.path.push(ProtocolConfig::PROTOCOL_VERSION_FIELD.name);
7550            self.finish()
7551        }
7552        pub fn feature_flags(mut self) -> String {
7553            self.path.push(ProtocolConfig::FEATURE_FLAGS_FIELD.name);
7554            self.finish()
7555        }
7556        pub fn attributes(mut self) -> String {
7557            self.path.push(ProtocolConfig::ATTRIBUTES_FIELD.name);
7558            self.finish()
7559        }
7560        pub fn configs(mut self) -> String {
7561            self.path.push(ProtocolConfig::CONFIGS_FIELD.name);
7562            self.finish()
7563        }
7564    }
7565    impl QueryOptions {
7566        pub const LIMIT_FIELD: &'static MessageField = &MessageField {
7567            name: "limit",
7568            json_name: "limit",
7569            number: 1i32,
7570            message_fields: None,
7571        };
7572        pub const AFTER_FIELD: &'static MessageField = &MessageField {
7573            name: "after",
7574            json_name: "after",
7575            number: 2i32,
7576            message_fields: None,
7577        };
7578        pub const BEFORE_FIELD: &'static MessageField = &MessageField {
7579            name: "before",
7580            json_name: "before",
7581            number: 3i32,
7582            message_fields: None,
7583        };
7584        pub const ORDERING_FIELD: &'static MessageField = &MessageField {
7585            name: "ordering",
7586            json_name: "ordering",
7587            number: 4i32,
7588            message_fields: None,
7589        };
7590    }
7591    impl MessageFields for QueryOptions {
7592        const FIELDS: &'static [&'static MessageField] = &[
7593            Self::LIMIT_FIELD,
7594            Self::AFTER_FIELD,
7595            Self::BEFORE_FIELD,
7596            Self::ORDERING_FIELD,
7597        ];
7598    }
7599    impl QueryOptions {
7600        pub fn path_builder() -> QueryOptionsFieldPathBuilder {
7601            QueryOptionsFieldPathBuilder::new()
7602        }
7603    }
7604    pub struct QueryOptionsFieldPathBuilder {
7605        path: Vec<&'static str>,
7606    }
7607    impl QueryOptionsFieldPathBuilder {
7608        #[allow(clippy::new_without_default)]
7609        pub fn new() -> Self {
7610            Self { path: Default::default() }
7611        }
7612        #[doc(hidden)]
7613        pub fn new_with_base(base: Vec<&'static str>) -> Self {
7614            Self { path: base }
7615        }
7616        pub fn finish(self) -> String {
7617            self.path.join(".")
7618        }
7619        pub fn limit(mut self) -> String {
7620            self.path.push(QueryOptions::LIMIT_FIELD.name);
7621            self.finish()
7622        }
7623        pub fn after(mut self) -> String {
7624            self.path.push(QueryOptions::AFTER_FIELD.name);
7625            self.finish()
7626        }
7627        pub fn before(mut self) -> String {
7628            self.path.push(QueryOptions::BEFORE_FIELD.name);
7629            self.finish()
7630        }
7631        pub fn ordering(mut self) -> String {
7632            self.path.push(QueryOptions::ORDERING_FIELD.name);
7633            self.finish()
7634        }
7635    }
7636    impl LedgerPosition {
7637        pub const CHECKPOINT_FIELD: &'static MessageField = &MessageField {
7638            name: "checkpoint",
7639            json_name: "checkpoint",
7640            number: 1i32,
7641            message_fields: None,
7642        };
7643        pub const TRANSACTION_INDEX_FIELD: &'static MessageField = &MessageField {
7644            name: "transaction_index",
7645            json_name: "transactionIndex",
7646            number: 2i32,
7647            message_fields: None,
7648        };
7649        pub const EVENT_INDEX_FIELD: &'static MessageField = &MessageField {
7650            name: "event_index",
7651            json_name: "eventIndex",
7652            number: 3i32,
7653            message_fields: None,
7654        };
7655    }
7656    impl MessageFields for LedgerPosition {
7657        const FIELDS: &'static [&'static MessageField] = &[
7658            Self::CHECKPOINT_FIELD,
7659            Self::TRANSACTION_INDEX_FIELD,
7660            Self::EVENT_INDEX_FIELD,
7661        ];
7662    }
7663    impl LedgerPosition {
7664        pub fn path_builder() -> LedgerPositionFieldPathBuilder {
7665            LedgerPositionFieldPathBuilder::new()
7666        }
7667    }
7668    pub struct LedgerPositionFieldPathBuilder {
7669        path: Vec<&'static str>,
7670    }
7671    impl LedgerPositionFieldPathBuilder {
7672        #[allow(clippy::new_without_default)]
7673        pub fn new() -> Self {
7674            Self { path: Default::default() }
7675        }
7676        #[doc(hidden)]
7677        pub fn new_with_base(base: Vec<&'static str>) -> Self {
7678            Self { path: base }
7679        }
7680        pub fn finish(self) -> String {
7681            self.path.join(".")
7682        }
7683        pub fn checkpoint(mut self) -> String {
7684            self.path.push(LedgerPosition::CHECKPOINT_FIELD.name);
7685            self.finish()
7686        }
7687        pub fn transaction_index(mut self) -> String {
7688            self.path.push(LedgerPosition::TRANSACTION_INDEX_FIELD.name);
7689            self.finish()
7690        }
7691        pub fn event_index(mut self) -> String {
7692            self.path.push(LedgerPosition::EVENT_INDEX_FIELD.name);
7693            self.finish()
7694        }
7695    }
7696    impl Watermark {
7697        pub const CURSOR_FIELD: &'static MessageField = &MessageField {
7698            name: "cursor",
7699            json_name: "cursor",
7700            number: 1i32,
7701            message_fields: None,
7702        };
7703        pub const CHECKPOINT_FIELD: &'static MessageField = &MessageField {
7704            name: "checkpoint",
7705            json_name: "checkpoint",
7706            number: 2i32,
7707            message_fields: None,
7708        };
7709        pub const CURSOR_POSITION_FIELD: &'static MessageField = &MessageField {
7710            name: "cursor_position",
7711            json_name: "cursorPosition",
7712            number: 4i32,
7713            message_fields: Some(LedgerPosition::FIELDS),
7714        };
7715    }
7716    impl MessageFields for Watermark {
7717        const FIELDS: &'static [&'static MessageField] = &[
7718            Self::CURSOR_FIELD,
7719            Self::CHECKPOINT_FIELD,
7720            Self::CURSOR_POSITION_FIELD,
7721        ];
7722    }
7723    impl Watermark {
7724        pub fn path_builder() -> WatermarkFieldPathBuilder {
7725            WatermarkFieldPathBuilder::new()
7726        }
7727    }
7728    pub struct WatermarkFieldPathBuilder {
7729        path: Vec<&'static str>,
7730    }
7731    impl WatermarkFieldPathBuilder {
7732        #[allow(clippy::new_without_default)]
7733        pub fn new() -> Self {
7734            Self { path: Default::default() }
7735        }
7736        #[doc(hidden)]
7737        pub fn new_with_base(base: Vec<&'static str>) -> Self {
7738            Self { path: base }
7739        }
7740        pub fn finish(self) -> String {
7741            self.path.join(".")
7742        }
7743        pub fn cursor(mut self) -> String {
7744            self.path.push(Watermark::CURSOR_FIELD.name);
7745            self.finish()
7746        }
7747        pub fn checkpoint(mut self) -> String {
7748            self.path.push(Watermark::CHECKPOINT_FIELD.name);
7749            self.finish()
7750        }
7751        pub fn cursor_position(mut self) -> LedgerPositionFieldPathBuilder {
7752            self.path.push(Watermark::CURSOR_POSITION_FIELD.name);
7753            LedgerPositionFieldPathBuilder::new_with_base(self.path)
7754        }
7755    }
7756    impl QueryEnd {
7757        pub const REASON_FIELD: &'static MessageField = &MessageField {
7758            name: "reason",
7759            json_name: "reason",
7760            number: 1i32,
7761            message_fields: None,
7762        };
7763    }
7764    impl MessageFields for QueryEnd {
7765        const FIELDS: &'static [&'static MessageField] = &[Self::REASON_FIELD];
7766    }
7767    impl QueryEnd {
7768        pub fn path_builder() -> QueryEndFieldPathBuilder {
7769            QueryEndFieldPathBuilder::new()
7770        }
7771    }
7772    pub struct QueryEndFieldPathBuilder {
7773        path: Vec<&'static str>,
7774    }
7775    impl QueryEndFieldPathBuilder {
7776        #[allow(clippy::new_without_default)]
7777        pub fn new() -> Self {
7778            Self { path: Default::default() }
7779        }
7780        #[doc(hidden)]
7781        pub fn new_with_base(base: Vec<&'static str>) -> Self {
7782            Self { path: base }
7783        }
7784        pub fn finish(self) -> String {
7785            self.path.join(".")
7786        }
7787        pub fn reason(mut self) -> String {
7788            self.path.push(QueryEnd::REASON_FIELD.name);
7789            self.finish()
7790        }
7791    }
7792    impl UserSignature {
7793        pub const BCS_FIELD: &'static MessageField = &MessageField {
7794            name: "bcs",
7795            json_name: "bcs",
7796            number: 1i32,
7797            message_fields: Some(Bcs::FIELDS),
7798        };
7799        pub const SCHEME_FIELD: &'static MessageField = &MessageField {
7800            name: "scheme",
7801            json_name: "scheme",
7802            number: 2i32,
7803            message_fields: None,
7804        };
7805        pub const SIMPLE_FIELD: &'static MessageField = &MessageField {
7806            name: "simple",
7807            json_name: "simple",
7808            number: 3i32,
7809            message_fields: Some(SimpleSignature::FIELDS),
7810        };
7811        pub const MULTISIG_FIELD: &'static MessageField = &MessageField {
7812            name: "multisig",
7813            json_name: "multisig",
7814            number: 4i32,
7815            message_fields: Some(MultisigAggregatedSignature::FIELDS),
7816        };
7817        pub const ZKLOGIN_FIELD: &'static MessageField = &MessageField {
7818            name: "zklogin",
7819            json_name: "zklogin",
7820            number: 5i32,
7821            message_fields: Some(ZkLoginAuthenticator::FIELDS),
7822        };
7823        pub const PASSKEY_FIELD: &'static MessageField = &MessageField {
7824            name: "passkey",
7825            json_name: "passkey",
7826            number: 6i32,
7827            message_fields: Some(PasskeyAuthenticator::FIELDS),
7828        };
7829    }
7830    impl MessageFields for UserSignature {
7831        const FIELDS: &'static [&'static MessageField] = &[
7832            Self::BCS_FIELD,
7833            Self::SCHEME_FIELD,
7834            Self::SIMPLE_FIELD,
7835            Self::MULTISIG_FIELD,
7836            Self::ZKLOGIN_FIELD,
7837            Self::PASSKEY_FIELD,
7838        ];
7839    }
7840    impl UserSignature {
7841        pub fn path_builder() -> UserSignatureFieldPathBuilder {
7842            UserSignatureFieldPathBuilder::new()
7843        }
7844    }
7845    pub struct UserSignatureFieldPathBuilder {
7846        path: Vec<&'static str>,
7847    }
7848    impl UserSignatureFieldPathBuilder {
7849        #[allow(clippy::new_without_default)]
7850        pub fn new() -> Self {
7851            Self { path: Default::default() }
7852        }
7853        #[doc(hidden)]
7854        pub fn new_with_base(base: Vec<&'static str>) -> Self {
7855            Self { path: base }
7856        }
7857        pub fn finish(self) -> String {
7858            self.path.join(".")
7859        }
7860        pub fn bcs(mut self) -> BcsFieldPathBuilder {
7861            self.path.push(UserSignature::BCS_FIELD.name);
7862            BcsFieldPathBuilder::new_with_base(self.path)
7863        }
7864        pub fn scheme(mut self) -> String {
7865            self.path.push(UserSignature::SCHEME_FIELD.name);
7866            self.finish()
7867        }
7868        pub fn simple(mut self) -> SimpleSignatureFieldPathBuilder {
7869            self.path.push(UserSignature::SIMPLE_FIELD.name);
7870            SimpleSignatureFieldPathBuilder::new_with_base(self.path)
7871        }
7872        pub fn multisig(mut self) -> MultisigAggregatedSignatureFieldPathBuilder {
7873            self.path.push(UserSignature::MULTISIG_FIELD.name);
7874            MultisigAggregatedSignatureFieldPathBuilder::new_with_base(self.path)
7875        }
7876        pub fn zklogin(mut self) -> ZkLoginAuthenticatorFieldPathBuilder {
7877            self.path.push(UserSignature::ZKLOGIN_FIELD.name);
7878            ZkLoginAuthenticatorFieldPathBuilder::new_with_base(self.path)
7879        }
7880        pub fn passkey(mut self) -> PasskeyAuthenticatorFieldPathBuilder {
7881            self.path.push(UserSignature::PASSKEY_FIELD.name);
7882            PasskeyAuthenticatorFieldPathBuilder::new_with_base(self.path)
7883        }
7884    }
7885    impl SimpleSignature {
7886        pub const SCHEME_FIELD: &'static MessageField = &MessageField {
7887            name: "scheme",
7888            json_name: "scheme",
7889            number: 1i32,
7890            message_fields: None,
7891        };
7892        pub const SIGNATURE_FIELD: &'static MessageField = &MessageField {
7893            name: "signature",
7894            json_name: "signature",
7895            number: 2i32,
7896            message_fields: None,
7897        };
7898        pub const PUBLIC_KEY_FIELD: &'static MessageField = &MessageField {
7899            name: "public_key",
7900            json_name: "publicKey",
7901            number: 3i32,
7902            message_fields: None,
7903        };
7904    }
7905    impl MessageFields for SimpleSignature {
7906        const FIELDS: &'static [&'static MessageField] = &[
7907            Self::SCHEME_FIELD,
7908            Self::SIGNATURE_FIELD,
7909            Self::PUBLIC_KEY_FIELD,
7910        ];
7911    }
7912    impl SimpleSignature {
7913        pub fn path_builder() -> SimpleSignatureFieldPathBuilder {
7914            SimpleSignatureFieldPathBuilder::new()
7915        }
7916    }
7917    pub struct SimpleSignatureFieldPathBuilder {
7918        path: Vec<&'static str>,
7919    }
7920    impl SimpleSignatureFieldPathBuilder {
7921        #[allow(clippy::new_without_default)]
7922        pub fn new() -> Self {
7923            Self { path: Default::default() }
7924        }
7925        #[doc(hidden)]
7926        pub fn new_with_base(base: Vec<&'static str>) -> Self {
7927            Self { path: base }
7928        }
7929        pub fn finish(self) -> String {
7930            self.path.join(".")
7931        }
7932        pub fn scheme(mut self) -> String {
7933            self.path.push(SimpleSignature::SCHEME_FIELD.name);
7934            self.finish()
7935        }
7936        pub fn signature(mut self) -> String {
7937            self.path.push(SimpleSignature::SIGNATURE_FIELD.name);
7938            self.finish()
7939        }
7940        pub fn public_key(mut self) -> String {
7941            self.path.push(SimpleSignature::PUBLIC_KEY_FIELD.name);
7942            self.finish()
7943        }
7944    }
7945    impl ZkLoginPublicIdentifier {
7946        pub const ISS_FIELD: &'static MessageField = &MessageField {
7947            name: "iss",
7948            json_name: "iss",
7949            number: 1i32,
7950            message_fields: None,
7951        };
7952        pub const ADDRESS_SEED_FIELD: &'static MessageField = &MessageField {
7953            name: "address_seed",
7954            json_name: "addressSeed",
7955            number: 2i32,
7956            message_fields: None,
7957        };
7958    }
7959    impl MessageFields for ZkLoginPublicIdentifier {
7960        const FIELDS: &'static [&'static MessageField] = &[
7961            Self::ISS_FIELD,
7962            Self::ADDRESS_SEED_FIELD,
7963        ];
7964    }
7965    impl ZkLoginPublicIdentifier {
7966        pub fn path_builder() -> ZkLoginPublicIdentifierFieldPathBuilder {
7967            ZkLoginPublicIdentifierFieldPathBuilder::new()
7968        }
7969    }
7970    pub struct ZkLoginPublicIdentifierFieldPathBuilder {
7971        path: Vec<&'static str>,
7972    }
7973    impl ZkLoginPublicIdentifierFieldPathBuilder {
7974        #[allow(clippy::new_without_default)]
7975        pub fn new() -> Self {
7976            Self { path: Default::default() }
7977        }
7978        #[doc(hidden)]
7979        pub fn new_with_base(base: Vec<&'static str>) -> Self {
7980            Self { path: base }
7981        }
7982        pub fn finish(self) -> String {
7983            self.path.join(".")
7984        }
7985        pub fn iss(mut self) -> String {
7986            self.path.push(ZkLoginPublicIdentifier::ISS_FIELD.name);
7987            self.finish()
7988        }
7989        pub fn address_seed(mut self) -> String {
7990            self.path.push(ZkLoginPublicIdentifier::ADDRESS_SEED_FIELD.name);
7991            self.finish()
7992        }
7993    }
7994    impl MultisigMemberPublicKey {
7995        pub const SCHEME_FIELD: &'static MessageField = &MessageField {
7996            name: "scheme",
7997            json_name: "scheme",
7998            number: 1i32,
7999            message_fields: None,
8000        };
8001        pub const PUBLIC_KEY_FIELD: &'static MessageField = &MessageField {
8002            name: "public_key",
8003            json_name: "publicKey",
8004            number: 2i32,
8005            message_fields: None,
8006        };
8007        pub const ZKLOGIN_FIELD: &'static MessageField = &MessageField {
8008            name: "zklogin",
8009            json_name: "zklogin",
8010            number: 3i32,
8011            message_fields: Some(ZkLoginPublicIdentifier::FIELDS),
8012        };
8013    }
8014    impl MessageFields for MultisigMemberPublicKey {
8015        const FIELDS: &'static [&'static MessageField] = &[
8016            Self::SCHEME_FIELD,
8017            Self::PUBLIC_KEY_FIELD,
8018            Self::ZKLOGIN_FIELD,
8019        ];
8020    }
8021    impl MultisigMemberPublicKey {
8022        pub fn path_builder() -> MultisigMemberPublicKeyFieldPathBuilder {
8023            MultisigMemberPublicKeyFieldPathBuilder::new()
8024        }
8025    }
8026    pub struct MultisigMemberPublicKeyFieldPathBuilder {
8027        path: Vec<&'static str>,
8028    }
8029    impl MultisigMemberPublicKeyFieldPathBuilder {
8030        #[allow(clippy::new_without_default)]
8031        pub fn new() -> Self {
8032            Self { path: Default::default() }
8033        }
8034        #[doc(hidden)]
8035        pub fn new_with_base(base: Vec<&'static str>) -> Self {
8036            Self { path: base }
8037        }
8038        pub fn finish(self) -> String {
8039            self.path.join(".")
8040        }
8041        pub fn scheme(mut self) -> String {
8042            self.path.push(MultisigMemberPublicKey::SCHEME_FIELD.name);
8043            self.finish()
8044        }
8045        pub fn public_key(mut self) -> String {
8046            self.path.push(MultisigMemberPublicKey::PUBLIC_KEY_FIELD.name);
8047            self.finish()
8048        }
8049        pub fn zklogin(mut self) -> ZkLoginPublicIdentifierFieldPathBuilder {
8050            self.path.push(MultisigMemberPublicKey::ZKLOGIN_FIELD.name);
8051            ZkLoginPublicIdentifierFieldPathBuilder::new_with_base(self.path)
8052        }
8053    }
8054    impl MultisigMember {
8055        pub const PUBLIC_KEY_FIELD: &'static MessageField = &MessageField {
8056            name: "public_key",
8057            json_name: "publicKey",
8058            number: 1i32,
8059            message_fields: Some(MultisigMemberPublicKey::FIELDS),
8060        };
8061        pub const WEIGHT_FIELD: &'static MessageField = &MessageField {
8062            name: "weight",
8063            json_name: "weight",
8064            number: 2i32,
8065            message_fields: None,
8066        };
8067    }
8068    impl MessageFields for MultisigMember {
8069        const FIELDS: &'static [&'static MessageField] = &[
8070            Self::PUBLIC_KEY_FIELD,
8071            Self::WEIGHT_FIELD,
8072        ];
8073    }
8074    impl MultisigMember {
8075        pub fn path_builder() -> MultisigMemberFieldPathBuilder {
8076            MultisigMemberFieldPathBuilder::new()
8077        }
8078    }
8079    pub struct MultisigMemberFieldPathBuilder {
8080        path: Vec<&'static str>,
8081    }
8082    impl MultisigMemberFieldPathBuilder {
8083        #[allow(clippy::new_without_default)]
8084        pub fn new() -> Self {
8085            Self { path: Default::default() }
8086        }
8087        #[doc(hidden)]
8088        pub fn new_with_base(base: Vec<&'static str>) -> Self {
8089            Self { path: base }
8090        }
8091        pub fn finish(self) -> String {
8092            self.path.join(".")
8093        }
8094        pub fn public_key(mut self) -> MultisigMemberPublicKeyFieldPathBuilder {
8095            self.path.push(MultisigMember::PUBLIC_KEY_FIELD.name);
8096            MultisigMemberPublicKeyFieldPathBuilder::new_with_base(self.path)
8097        }
8098        pub fn weight(mut self) -> String {
8099            self.path.push(MultisigMember::WEIGHT_FIELD.name);
8100            self.finish()
8101        }
8102    }
8103    impl MultisigCommittee {
8104        pub const MEMBERS_FIELD: &'static MessageField = &MessageField {
8105            name: "members",
8106            json_name: "members",
8107            number: 1i32,
8108            message_fields: Some(MultisigMember::FIELDS),
8109        };
8110        pub const THRESHOLD_FIELD: &'static MessageField = &MessageField {
8111            name: "threshold",
8112            json_name: "threshold",
8113            number: 2i32,
8114            message_fields: None,
8115        };
8116    }
8117    impl MessageFields for MultisigCommittee {
8118        const FIELDS: &'static [&'static MessageField] = &[
8119            Self::MEMBERS_FIELD,
8120            Self::THRESHOLD_FIELD,
8121        ];
8122    }
8123    impl MultisigCommittee {
8124        pub fn path_builder() -> MultisigCommitteeFieldPathBuilder {
8125            MultisigCommitteeFieldPathBuilder::new()
8126        }
8127    }
8128    pub struct MultisigCommitteeFieldPathBuilder {
8129        path: Vec<&'static str>,
8130    }
8131    impl MultisigCommitteeFieldPathBuilder {
8132        #[allow(clippy::new_without_default)]
8133        pub fn new() -> Self {
8134            Self { path: Default::default() }
8135        }
8136        #[doc(hidden)]
8137        pub fn new_with_base(base: Vec<&'static str>) -> Self {
8138            Self { path: base }
8139        }
8140        pub fn finish(self) -> String {
8141            self.path.join(".")
8142        }
8143        pub fn members(mut self) -> MultisigMemberFieldPathBuilder {
8144            self.path.push(MultisigCommittee::MEMBERS_FIELD.name);
8145            MultisigMemberFieldPathBuilder::new_with_base(self.path)
8146        }
8147        pub fn threshold(mut self) -> String {
8148            self.path.push(MultisigCommittee::THRESHOLD_FIELD.name);
8149            self.finish()
8150        }
8151    }
8152    impl MultisigAggregatedSignature {
8153        pub const SIGNATURES_FIELD: &'static MessageField = &MessageField {
8154            name: "signatures",
8155            json_name: "signatures",
8156            number: 1i32,
8157            message_fields: Some(MultisigMemberSignature::FIELDS),
8158        };
8159        pub const BITMAP_FIELD: &'static MessageField = &MessageField {
8160            name: "bitmap",
8161            json_name: "bitmap",
8162            number: 2i32,
8163            message_fields: None,
8164        };
8165        pub const LEGACY_BITMAP_FIELD: &'static MessageField = &MessageField {
8166            name: "legacy_bitmap",
8167            json_name: "legacyBitmap",
8168            number: 3i32,
8169            message_fields: None,
8170        };
8171        pub const COMMITTEE_FIELD: &'static MessageField = &MessageField {
8172            name: "committee",
8173            json_name: "committee",
8174            number: 4i32,
8175            message_fields: Some(MultisigCommittee::FIELDS),
8176        };
8177    }
8178    impl MessageFields for MultisigAggregatedSignature {
8179        const FIELDS: &'static [&'static MessageField] = &[
8180            Self::SIGNATURES_FIELD,
8181            Self::BITMAP_FIELD,
8182            Self::LEGACY_BITMAP_FIELD,
8183            Self::COMMITTEE_FIELD,
8184        ];
8185    }
8186    impl MultisigAggregatedSignature {
8187        pub fn path_builder() -> MultisigAggregatedSignatureFieldPathBuilder {
8188            MultisigAggregatedSignatureFieldPathBuilder::new()
8189        }
8190    }
8191    pub struct MultisigAggregatedSignatureFieldPathBuilder {
8192        path: Vec<&'static str>,
8193    }
8194    impl MultisigAggregatedSignatureFieldPathBuilder {
8195        #[allow(clippy::new_without_default)]
8196        pub fn new() -> Self {
8197            Self { path: Default::default() }
8198        }
8199        #[doc(hidden)]
8200        pub fn new_with_base(base: Vec<&'static str>) -> Self {
8201            Self { path: base }
8202        }
8203        pub fn finish(self) -> String {
8204            self.path.join(".")
8205        }
8206        pub fn signatures(mut self) -> MultisigMemberSignatureFieldPathBuilder {
8207            self.path.push(MultisigAggregatedSignature::SIGNATURES_FIELD.name);
8208            MultisigMemberSignatureFieldPathBuilder::new_with_base(self.path)
8209        }
8210        pub fn bitmap(mut self) -> String {
8211            self.path.push(MultisigAggregatedSignature::BITMAP_FIELD.name);
8212            self.finish()
8213        }
8214        pub fn legacy_bitmap(mut self) -> String {
8215            self.path.push(MultisigAggregatedSignature::LEGACY_BITMAP_FIELD.name);
8216            self.finish()
8217        }
8218        pub fn committee(mut self) -> MultisigCommitteeFieldPathBuilder {
8219            self.path.push(MultisigAggregatedSignature::COMMITTEE_FIELD.name);
8220            MultisigCommitteeFieldPathBuilder::new_with_base(self.path)
8221        }
8222    }
8223    impl MultisigMemberSignature {
8224        pub const SCHEME_FIELD: &'static MessageField = &MessageField {
8225            name: "scheme",
8226            json_name: "scheme",
8227            number: 1i32,
8228            message_fields: None,
8229        };
8230        pub const SIGNATURE_FIELD: &'static MessageField = &MessageField {
8231            name: "signature",
8232            json_name: "signature",
8233            number: 2i32,
8234            message_fields: None,
8235        };
8236        pub const ZKLOGIN_FIELD: &'static MessageField = &MessageField {
8237            name: "zklogin",
8238            json_name: "zklogin",
8239            number: 3i32,
8240            message_fields: Some(ZkLoginAuthenticator::FIELDS),
8241        };
8242        pub const PASSKEY_FIELD: &'static MessageField = &MessageField {
8243            name: "passkey",
8244            json_name: "passkey",
8245            number: 4i32,
8246            message_fields: Some(PasskeyAuthenticator::FIELDS),
8247        };
8248    }
8249    impl MessageFields for MultisigMemberSignature {
8250        const FIELDS: &'static [&'static MessageField] = &[
8251            Self::SCHEME_FIELD,
8252            Self::SIGNATURE_FIELD,
8253            Self::ZKLOGIN_FIELD,
8254            Self::PASSKEY_FIELD,
8255        ];
8256    }
8257    impl MultisigMemberSignature {
8258        pub fn path_builder() -> MultisigMemberSignatureFieldPathBuilder {
8259            MultisigMemberSignatureFieldPathBuilder::new()
8260        }
8261    }
8262    pub struct MultisigMemberSignatureFieldPathBuilder {
8263        path: Vec<&'static str>,
8264    }
8265    impl MultisigMemberSignatureFieldPathBuilder {
8266        #[allow(clippy::new_without_default)]
8267        pub fn new() -> Self {
8268            Self { path: Default::default() }
8269        }
8270        #[doc(hidden)]
8271        pub fn new_with_base(base: Vec<&'static str>) -> Self {
8272            Self { path: base }
8273        }
8274        pub fn finish(self) -> String {
8275            self.path.join(".")
8276        }
8277        pub fn scheme(mut self) -> String {
8278            self.path.push(MultisigMemberSignature::SCHEME_FIELD.name);
8279            self.finish()
8280        }
8281        pub fn signature(mut self) -> String {
8282            self.path.push(MultisigMemberSignature::SIGNATURE_FIELD.name);
8283            self.finish()
8284        }
8285        pub fn zklogin(mut self) -> ZkLoginAuthenticatorFieldPathBuilder {
8286            self.path.push(MultisigMemberSignature::ZKLOGIN_FIELD.name);
8287            ZkLoginAuthenticatorFieldPathBuilder::new_with_base(self.path)
8288        }
8289        pub fn passkey(mut self) -> PasskeyAuthenticatorFieldPathBuilder {
8290            self.path.push(MultisigMemberSignature::PASSKEY_FIELD.name);
8291            PasskeyAuthenticatorFieldPathBuilder::new_with_base(self.path)
8292        }
8293    }
8294    impl ZkLoginAuthenticator {
8295        pub const INPUTS_FIELD: &'static MessageField = &MessageField {
8296            name: "inputs",
8297            json_name: "inputs",
8298            number: 1i32,
8299            message_fields: Some(ZkLoginInputs::FIELDS),
8300        };
8301        pub const MAX_EPOCH_FIELD: &'static MessageField = &MessageField {
8302            name: "max_epoch",
8303            json_name: "maxEpoch",
8304            number: 2i32,
8305            message_fields: None,
8306        };
8307        pub const SIGNATURE_FIELD: &'static MessageField = &MessageField {
8308            name: "signature",
8309            json_name: "signature",
8310            number: 3i32,
8311            message_fields: Some(SimpleSignature::FIELDS),
8312        };
8313        pub const PUBLIC_IDENTIFIER_FIELD: &'static MessageField = &MessageField {
8314            name: "public_identifier",
8315            json_name: "publicIdentifier",
8316            number: 4i32,
8317            message_fields: Some(ZkLoginPublicIdentifier::FIELDS),
8318        };
8319        pub const JWK_ID_FIELD: &'static MessageField = &MessageField {
8320            name: "jwk_id",
8321            json_name: "jwkId",
8322            number: 5i32,
8323            message_fields: Some(JwkId::FIELDS),
8324        };
8325    }
8326    impl MessageFields for ZkLoginAuthenticator {
8327        const FIELDS: &'static [&'static MessageField] = &[
8328            Self::INPUTS_FIELD,
8329            Self::MAX_EPOCH_FIELD,
8330            Self::SIGNATURE_FIELD,
8331            Self::PUBLIC_IDENTIFIER_FIELD,
8332            Self::JWK_ID_FIELD,
8333        ];
8334    }
8335    impl ZkLoginAuthenticator {
8336        pub fn path_builder() -> ZkLoginAuthenticatorFieldPathBuilder {
8337            ZkLoginAuthenticatorFieldPathBuilder::new()
8338        }
8339    }
8340    pub struct ZkLoginAuthenticatorFieldPathBuilder {
8341        path: Vec<&'static str>,
8342    }
8343    impl ZkLoginAuthenticatorFieldPathBuilder {
8344        #[allow(clippy::new_without_default)]
8345        pub fn new() -> Self {
8346            Self { path: Default::default() }
8347        }
8348        #[doc(hidden)]
8349        pub fn new_with_base(base: Vec<&'static str>) -> Self {
8350            Self { path: base }
8351        }
8352        pub fn finish(self) -> String {
8353            self.path.join(".")
8354        }
8355        pub fn inputs(mut self) -> ZkLoginInputsFieldPathBuilder {
8356            self.path.push(ZkLoginAuthenticator::INPUTS_FIELD.name);
8357            ZkLoginInputsFieldPathBuilder::new_with_base(self.path)
8358        }
8359        pub fn max_epoch(mut self) -> String {
8360            self.path.push(ZkLoginAuthenticator::MAX_EPOCH_FIELD.name);
8361            self.finish()
8362        }
8363        pub fn signature(mut self) -> SimpleSignatureFieldPathBuilder {
8364            self.path.push(ZkLoginAuthenticator::SIGNATURE_FIELD.name);
8365            SimpleSignatureFieldPathBuilder::new_with_base(self.path)
8366        }
8367        pub fn public_identifier(mut self) -> ZkLoginPublicIdentifierFieldPathBuilder {
8368            self.path.push(ZkLoginAuthenticator::PUBLIC_IDENTIFIER_FIELD.name);
8369            ZkLoginPublicIdentifierFieldPathBuilder::new_with_base(self.path)
8370        }
8371        pub fn jwk_id(mut self) -> JwkIdFieldPathBuilder {
8372            self.path.push(ZkLoginAuthenticator::JWK_ID_FIELD.name);
8373            JwkIdFieldPathBuilder::new_with_base(self.path)
8374        }
8375    }
8376    impl ZkLoginInputs {
8377        pub const PROOF_POINTS_FIELD: &'static MessageField = &MessageField {
8378            name: "proof_points",
8379            json_name: "proofPoints",
8380            number: 1i32,
8381            message_fields: Some(ZkLoginProof::FIELDS),
8382        };
8383        pub const ISS_BASE64_DETAILS_FIELD: &'static MessageField = &MessageField {
8384            name: "iss_base64_details",
8385            json_name: "issBase64Details",
8386            number: 2i32,
8387            message_fields: Some(ZkLoginClaim::FIELDS),
8388        };
8389        pub const HEADER_BASE64_FIELD: &'static MessageField = &MessageField {
8390            name: "header_base64",
8391            json_name: "headerBase64",
8392            number: 3i32,
8393            message_fields: None,
8394        };
8395        pub const ADDRESS_SEED_FIELD: &'static MessageField = &MessageField {
8396            name: "address_seed",
8397            json_name: "addressSeed",
8398            number: 4i32,
8399            message_fields: None,
8400        };
8401    }
8402    impl MessageFields for ZkLoginInputs {
8403        const FIELDS: &'static [&'static MessageField] = &[
8404            Self::PROOF_POINTS_FIELD,
8405            Self::ISS_BASE64_DETAILS_FIELD,
8406            Self::HEADER_BASE64_FIELD,
8407            Self::ADDRESS_SEED_FIELD,
8408        ];
8409    }
8410    impl ZkLoginInputs {
8411        pub fn path_builder() -> ZkLoginInputsFieldPathBuilder {
8412            ZkLoginInputsFieldPathBuilder::new()
8413        }
8414    }
8415    pub struct ZkLoginInputsFieldPathBuilder {
8416        path: Vec<&'static str>,
8417    }
8418    impl ZkLoginInputsFieldPathBuilder {
8419        #[allow(clippy::new_without_default)]
8420        pub fn new() -> Self {
8421            Self { path: Default::default() }
8422        }
8423        #[doc(hidden)]
8424        pub fn new_with_base(base: Vec<&'static str>) -> Self {
8425            Self { path: base }
8426        }
8427        pub fn finish(self) -> String {
8428            self.path.join(".")
8429        }
8430        pub fn proof_points(mut self) -> ZkLoginProofFieldPathBuilder {
8431            self.path.push(ZkLoginInputs::PROOF_POINTS_FIELD.name);
8432            ZkLoginProofFieldPathBuilder::new_with_base(self.path)
8433        }
8434        pub fn iss_base64_details(mut self) -> ZkLoginClaimFieldPathBuilder {
8435            self.path.push(ZkLoginInputs::ISS_BASE64_DETAILS_FIELD.name);
8436            ZkLoginClaimFieldPathBuilder::new_with_base(self.path)
8437        }
8438        pub fn header_base64(mut self) -> String {
8439            self.path.push(ZkLoginInputs::HEADER_BASE64_FIELD.name);
8440            self.finish()
8441        }
8442        pub fn address_seed(mut self) -> String {
8443            self.path.push(ZkLoginInputs::ADDRESS_SEED_FIELD.name);
8444            self.finish()
8445        }
8446    }
8447    impl ZkLoginProof {
8448        pub const A_FIELD: &'static MessageField = &MessageField {
8449            name: "a",
8450            json_name: "a",
8451            number: 1i32,
8452            message_fields: Some(CircomG1::FIELDS),
8453        };
8454        pub const B_FIELD: &'static MessageField = &MessageField {
8455            name: "b",
8456            json_name: "b",
8457            number: 2i32,
8458            message_fields: Some(CircomG2::FIELDS),
8459        };
8460        pub const C_FIELD: &'static MessageField = &MessageField {
8461            name: "c",
8462            json_name: "c",
8463            number: 3i32,
8464            message_fields: Some(CircomG1::FIELDS),
8465        };
8466    }
8467    impl MessageFields for ZkLoginProof {
8468        const FIELDS: &'static [&'static MessageField] = &[
8469            Self::A_FIELD,
8470            Self::B_FIELD,
8471            Self::C_FIELD,
8472        ];
8473    }
8474    impl ZkLoginProof {
8475        pub fn path_builder() -> ZkLoginProofFieldPathBuilder {
8476            ZkLoginProofFieldPathBuilder::new()
8477        }
8478    }
8479    pub struct ZkLoginProofFieldPathBuilder {
8480        path: Vec<&'static str>,
8481    }
8482    impl ZkLoginProofFieldPathBuilder {
8483        #[allow(clippy::new_without_default)]
8484        pub fn new() -> Self {
8485            Self { path: Default::default() }
8486        }
8487        #[doc(hidden)]
8488        pub fn new_with_base(base: Vec<&'static str>) -> Self {
8489            Self { path: base }
8490        }
8491        pub fn finish(self) -> String {
8492            self.path.join(".")
8493        }
8494        pub fn a(mut self) -> CircomG1FieldPathBuilder {
8495            self.path.push(ZkLoginProof::A_FIELD.name);
8496            CircomG1FieldPathBuilder::new_with_base(self.path)
8497        }
8498        pub fn b(mut self) -> CircomG2FieldPathBuilder {
8499            self.path.push(ZkLoginProof::B_FIELD.name);
8500            CircomG2FieldPathBuilder::new_with_base(self.path)
8501        }
8502        pub fn c(mut self) -> CircomG1FieldPathBuilder {
8503            self.path.push(ZkLoginProof::C_FIELD.name);
8504            CircomG1FieldPathBuilder::new_with_base(self.path)
8505        }
8506    }
8507    impl ZkLoginClaim {
8508        pub const VALUE_FIELD: &'static MessageField = &MessageField {
8509            name: "value",
8510            json_name: "value",
8511            number: 1i32,
8512            message_fields: None,
8513        };
8514        pub const INDEX_MOD_4_FIELD: &'static MessageField = &MessageField {
8515            name: "index_mod_4",
8516            json_name: "indexMod4",
8517            number: 2i32,
8518            message_fields: None,
8519        };
8520    }
8521    impl MessageFields for ZkLoginClaim {
8522        const FIELDS: &'static [&'static MessageField] = &[
8523            Self::VALUE_FIELD,
8524            Self::INDEX_MOD_4_FIELD,
8525        ];
8526    }
8527    impl ZkLoginClaim {
8528        pub fn path_builder() -> ZkLoginClaimFieldPathBuilder {
8529            ZkLoginClaimFieldPathBuilder::new()
8530        }
8531    }
8532    pub struct ZkLoginClaimFieldPathBuilder {
8533        path: Vec<&'static str>,
8534    }
8535    impl ZkLoginClaimFieldPathBuilder {
8536        #[allow(clippy::new_without_default)]
8537        pub fn new() -> Self {
8538            Self { path: Default::default() }
8539        }
8540        #[doc(hidden)]
8541        pub fn new_with_base(base: Vec<&'static str>) -> Self {
8542            Self { path: base }
8543        }
8544        pub fn finish(self) -> String {
8545            self.path.join(".")
8546        }
8547        pub fn value(mut self) -> String {
8548            self.path.push(ZkLoginClaim::VALUE_FIELD.name);
8549            self.finish()
8550        }
8551        pub fn index_mod_4(mut self) -> String {
8552            self.path.push(ZkLoginClaim::INDEX_MOD_4_FIELD.name);
8553            self.finish()
8554        }
8555    }
8556    impl CircomG1 {
8557        pub const E0_FIELD: &'static MessageField = &MessageField {
8558            name: "e0",
8559            json_name: "e0",
8560            number: 1i32,
8561            message_fields: None,
8562        };
8563        pub const E1_FIELD: &'static MessageField = &MessageField {
8564            name: "e1",
8565            json_name: "e1",
8566            number: 2i32,
8567            message_fields: None,
8568        };
8569        pub const E2_FIELD: &'static MessageField = &MessageField {
8570            name: "e2",
8571            json_name: "e2",
8572            number: 3i32,
8573            message_fields: None,
8574        };
8575    }
8576    impl MessageFields for CircomG1 {
8577        const FIELDS: &'static [&'static MessageField] = &[
8578            Self::E0_FIELD,
8579            Self::E1_FIELD,
8580            Self::E2_FIELD,
8581        ];
8582    }
8583    impl CircomG1 {
8584        pub fn path_builder() -> CircomG1FieldPathBuilder {
8585            CircomG1FieldPathBuilder::new()
8586        }
8587    }
8588    pub struct CircomG1FieldPathBuilder {
8589        path: Vec<&'static str>,
8590    }
8591    impl CircomG1FieldPathBuilder {
8592        #[allow(clippy::new_without_default)]
8593        pub fn new() -> Self {
8594            Self { path: Default::default() }
8595        }
8596        #[doc(hidden)]
8597        pub fn new_with_base(base: Vec<&'static str>) -> Self {
8598            Self { path: base }
8599        }
8600        pub fn finish(self) -> String {
8601            self.path.join(".")
8602        }
8603        pub fn e0(mut self) -> String {
8604            self.path.push(CircomG1::E0_FIELD.name);
8605            self.finish()
8606        }
8607        pub fn e1(mut self) -> String {
8608            self.path.push(CircomG1::E1_FIELD.name);
8609            self.finish()
8610        }
8611        pub fn e2(mut self) -> String {
8612            self.path.push(CircomG1::E2_FIELD.name);
8613            self.finish()
8614        }
8615    }
8616    impl CircomG2 {
8617        pub const E00_FIELD: &'static MessageField = &MessageField {
8618            name: "e00",
8619            json_name: "e00",
8620            number: 1i32,
8621            message_fields: None,
8622        };
8623        pub const E01_FIELD: &'static MessageField = &MessageField {
8624            name: "e01",
8625            json_name: "e01",
8626            number: 2i32,
8627            message_fields: None,
8628        };
8629        pub const E10_FIELD: &'static MessageField = &MessageField {
8630            name: "e10",
8631            json_name: "e10",
8632            number: 3i32,
8633            message_fields: None,
8634        };
8635        pub const E11_FIELD: &'static MessageField = &MessageField {
8636            name: "e11",
8637            json_name: "e11",
8638            number: 4i32,
8639            message_fields: None,
8640        };
8641        pub const E20_FIELD: &'static MessageField = &MessageField {
8642            name: "e20",
8643            json_name: "e20",
8644            number: 5i32,
8645            message_fields: None,
8646        };
8647        pub const E21_FIELD: &'static MessageField = &MessageField {
8648            name: "e21",
8649            json_name: "e21",
8650            number: 6i32,
8651            message_fields: None,
8652        };
8653    }
8654    impl MessageFields for CircomG2 {
8655        const FIELDS: &'static [&'static MessageField] = &[
8656            Self::E00_FIELD,
8657            Self::E01_FIELD,
8658            Self::E10_FIELD,
8659            Self::E11_FIELD,
8660            Self::E20_FIELD,
8661            Self::E21_FIELD,
8662        ];
8663    }
8664    impl CircomG2 {
8665        pub fn path_builder() -> CircomG2FieldPathBuilder {
8666            CircomG2FieldPathBuilder::new()
8667        }
8668    }
8669    pub struct CircomG2FieldPathBuilder {
8670        path: Vec<&'static str>,
8671    }
8672    impl CircomG2FieldPathBuilder {
8673        #[allow(clippy::new_without_default)]
8674        pub fn new() -> Self {
8675            Self { path: Default::default() }
8676        }
8677        #[doc(hidden)]
8678        pub fn new_with_base(base: Vec<&'static str>) -> Self {
8679            Self { path: base }
8680        }
8681        pub fn finish(self) -> String {
8682            self.path.join(".")
8683        }
8684        pub fn e00(mut self) -> String {
8685            self.path.push(CircomG2::E00_FIELD.name);
8686            self.finish()
8687        }
8688        pub fn e01(mut self) -> String {
8689            self.path.push(CircomG2::E01_FIELD.name);
8690            self.finish()
8691        }
8692        pub fn e10(mut self) -> String {
8693            self.path.push(CircomG2::E10_FIELD.name);
8694            self.finish()
8695        }
8696        pub fn e11(mut self) -> String {
8697            self.path.push(CircomG2::E11_FIELD.name);
8698            self.finish()
8699        }
8700        pub fn e20(mut self) -> String {
8701            self.path.push(CircomG2::E20_FIELD.name);
8702            self.finish()
8703        }
8704        pub fn e21(mut self) -> String {
8705            self.path.push(CircomG2::E21_FIELD.name);
8706            self.finish()
8707        }
8708    }
8709    impl PasskeyAuthenticator {
8710        pub const AUTHENTICATOR_DATA_FIELD: &'static MessageField = &MessageField {
8711            name: "authenticator_data",
8712            json_name: "authenticatorData",
8713            number: 1i32,
8714            message_fields: None,
8715        };
8716        pub const CLIENT_DATA_JSON_FIELD: &'static MessageField = &MessageField {
8717            name: "client_data_json",
8718            json_name: "clientDataJson",
8719            number: 2i32,
8720            message_fields: None,
8721        };
8722        pub const SIGNATURE_FIELD: &'static MessageField = &MessageField {
8723            name: "signature",
8724            json_name: "signature",
8725            number: 3i32,
8726            message_fields: Some(SimpleSignature::FIELDS),
8727        };
8728    }
8729    impl MessageFields for PasskeyAuthenticator {
8730        const FIELDS: &'static [&'static MessageField] = &[
8731            Self::AUTHENTICATOR_DATA_FIELD,
8732            Self::CLIENT_DATA_JSON_FIELD,
8733            Self::SIGNATURE_FIELD,
8734        ];
8735    }
8736    impl PasskeyAuthenticator {
8737        pub fn path_builder() -> PasskeyAuthenticatorFieldPathBuilder {
8738            PasskeyAuthenticatorFieldPathBuilder::new()
8739        }
8740    }
8741    pub struct PasskeyAuthenticatorFieldPathBuilder {
8742        path: Vec<&'static str>,
8743    }
8744    impl PasskeyAuthenticatorFieldPathBuilder {
8745        #[allow(clippy::new_without_default)]
8746        pub fn new() -> Self {
8747            Self { path: Default::default() }
8748        }
8749        #[doc(hidden)]
8750        pub fn new_with_base(base: Vec<&'static str>) -> Self {
8751            Self { path: base }
8752        }
8753        pub fn finish(self) -> String {
8754            self.path.join(".")
8755        }
8756        pub fn authenticator_data(mut self) -> String {
8757            self.path.push(PasskeyAuthenticator::AUTHENTICATOR_DATA_FIELD.name);
8758            self.finish()
8759        }
8760        pub fn client_data_json(mut self) -> String {
8761            self.path.push(PasskeyAuthenticator::CLIENT_DATA_JSON_FIELD.name);
8762            self.finish()
8763        }
8764        pub fn signature(mut self) -> SimpleSignatureFieldPathBuilder {
8765            self.path.push(PasskeyAuthenticator::SIGNATURE_FIELD.name);
8766            SimpleSignatureFieldPathBuilder::new_with_base(self.path)
8767        }
8768    }
8769    impl ValidatorCommittee {
8770        pub const EPOCH_FIELD: &'static MessageField = &MessageField {
8771            name: "epoch",
8772            json_name: "epoch",
8773            number: 1i32,
8774            message_fields: None,
8775        };
8776        pub const MEMBERS_FIELD: &'static MessageField = &MessageField {
8777            name: "members",
8778            json_name: "members",
8779            number: 2i32,
8780            message_fields: Some(ValidatorCommitteeMember::FIELDS),
8781        };
8782    }
8783    impl MessageFields for ValidatorCommittee {
8784        const FIELDS: &'static [&'static MessageField] = &[
8785            Self::EPOCH_FIELD,
8786            Self::MEMBERS_FIELD,
8787        ];
8788    }
8789    impl ValidatorCommittee {
8790        pub fn path_builder() -> ValidatorCommitteeFieldPathBuilder {
8791            ValidatorCommitteeFieldPathBuilder::new()
8792        }
8793    }
8794    pub struct ValidatorCommitteeFieldPathBuilder {
8795        path: Vec<&'static str>,
8796    }
8797    impl ValidatorCommitteeFieldPathBuilder {
8798        #[allow(clippy::new_without_default)]
8799        pub fn new() -> Self {
8800            Self { path: Default::default() }
8801        }
8802        #[doc(hidden)]
8803        pub fn new_with_base(base: Vec<&'static str>) -> Self {
8804            Self { path: base }
8805        }
8806        pub fn finish(self) -> String {
8807            self.path.join(".")
8808        }
8809        pub fn epoch(mut self) -> String {
8810            self.path.push(ValidatorCommittee::EPOCH_FIELD.name);
8811            self.finish()
8812        }
8813        pub fn members(mut self) -> ValidatorCommitteeMemberFieldPathBuilder {
8814            self.path.push(ValidatorCommittee::MEMBERS_FIELD.name);
8815            ValidatorCommitteeMemberFieldPathBuilder::new_with_base(self.path)
8816        }
8817    }
8818    impl ValidatorCommitteeMember {
8819        pub const PUBLIC_KEY_FIELD: &'static MessageField = &MessageField {
8820            name: "public_key",
8821            json_name: "publicKey",
8822            number: 1i32,
8823            message_fields: None,
8824        };
8825        pub const WEIGHT_FIELD: &'static MessageField = &MessageField {
8826            name: "weight",
8827            json_name: "weight",
8828            number: 2i32,
8829            message_fields: None,
8830        };
8831    }
8832    impl MessageFields for ValidatorCommitteeMember {
8833        const FIELDS: &'static [&'static MessageField] = &[
8834            Self::PUBLIC_KEY_FIELD,
8835            Self::WEIGHT_FIELD,
8836        ];
8837    }
8838    impl ValidatorCommitteeMember {
8839        pub fn path_builder() -> ValidatorCommitteeMemberFieldPathBuilder {
8840            ValidatorCommitteeMemberFieldPathBuilder::new()
8841        }
8842    }
8843    pub struct ValidatorCommitteeMemberFieldPathBuilder {
8844        path: Vec<&'static str>,
8845    }
8846    impl ValidatorCommitteeMemberFieldPathBuilder {
8847        #[allow(clippy::new_without_default)]
8848        pub fn new() -> Self {
8849            Self { path: Default::default() }
8850        }
8851        #[doc(hidden)]
8852        pub fn new_with_base(base: Vec<&'static str>) -> Self {
8853            Self { path: base }
8854        }
8855        pub fn finish(self) -> String {
8856            self.path.join(".")
8857        }
8858        pub fn public_key(mut self) -> String {
8859            self.path.push(ValidatorCommitteeMember::PUBLIC_KEY_FIELD.name);
8860            self.finish()
8861        }
8862        pub fn weight(mut self) -> String {
8863            self.path.push(ValidatorCommitteeMember::WEIGHT_FIELD.name);
8864            self.finish()
8865        }
8866    }
8867    impl ValidatorAggregatedSignature {
8868        pub const EPOCH_FIELD: &'static MessageField = &MessageField {
8869            name: "epoch",
8870            json_name: "epoch",
8871            number: 1i32,
8872            message_fields: None,
8873        };
8874        pub const SIGNATURE_FIELD: &'static MessageField = &MessageField {
8875            name: "signature",
8876            json_name: "signature",
8877            number: 2i32,
8878            message_fields: None,
8879        };
8880        pub const BITMAP_FIELD: &'static MessageField = &MessageField {
8881            name: "bitmap",
8882            json_name: "bitmap",
8883            number: 3i32,
8884            message_fields: None,
8885        };
8886    }
8887    impl MessageFields for ValidatorAggregatedSignature {
8888        const FIELDS: &'static [&'static MessageField] = &[
8889            Self::EPOCH_FIELD,
8890            Self::SIGNATURE_FIELD,
8891            Self::BITMAP_FIELD,
8892        ];
8893    }
8894    impl ValidatorAggregatedSignature {
8895        pub fn path_builder() -> ValidatorAggregatedSignatureFieldPathBuilder {
8896            ValidatorAggregatedSignatureFieldPathBuilder::new()
8897        }
8898    }
8899    pub struct ValidatorAggregatedSignatureFieldPathBuilder {
8900        path: Vec<&'static str>,
8901    }
8902    impl ValidatorAggregatedSignatureFieldPathBuilder {
8903        #[allow(clippy::new_without_default)]
8904        pub fn new() -> Self {
8905            Self { path: Default::default() }
8906        }
8907        #[doc(hidden)]
8908        pub fn new_with_base(base: Vec<&'static str>) -> Self {
8909            Self { path: base }
8910        }
8911        pub fn finish(self) -> String {
8912            self.path.join(".")
8913        }
8914        pub fn epoch(mut self) -> String {
8915            self.path.push(ValidatorAggregatedSignature::EPOCH_FIELD.name);
8916            self.finish()
8917        }
8918        pub fn signature(mut self) -> String {
8919            self.path.push(ValidatorAggregatedSignature::SIGNATURE_FIELD.name);
8920            self.finish()
8921        }
8922        pub fn bitmap(mut self) -> String {
8923            self.path.push(ValidatorAggregatedSignature::BITMAP_FIELD.name);
8924            self.finish()
8925        }
8926    }
8927    impl VerifySignatureRequest {
8928        pub const MESSAGE_FIELD: &'static MessageField = &MessageField {
8929            name: "message",
8930            json_name: "message",
8931            number: 1i32,
8932            message_fields: Some(Bcs::FIELDS),
8933        };
8934        pub const SIGNATURE_FIELD: &'static MessageField = &MessageField {
8935            name: "signature",
8936            json_name: "signature",
8937            number: 2i32,
8938            message_fields: Some(UserSignature::FIELDS),
8939        };
8940        pub const ADDRESS_FIELD: &'static MessageField = &MessageField {
8941            name: "address",
8942            json_name: "address",
8943            number: 3i32,
8944            message_fields: None,
8945        };
8946        pub const JWKS_FIELD: &'static MessageField = &MessageField {
8947            name: "jwks",
8948            json_name: "jwks",
8949            number: 4i32,
8950            message_fields: Some(ActiveJwk::FIELDS),
8951        };
8952        pub const CHECK_ADDRESS_ALIASES_FIELD: &'static MessageField = &MessageField {
8953            name: "check_address_aliases",
8954            json_name: "checkAddressAliases",
8955            number: 6i32,
8956            message_fields: None,
8957        };
8958    }
8959    impl MessageFields for VerifySignatureRequest {
8960        const FIELDS: &'static [&'static MessageField] = &[
8961            Self::MESSAGE_FIELD,
8962            Self::SIGNATURE_FIELD,
8963            Self::ADDRESS_FIELD,
8964            Self::JWKS_FIELD,
8965            Self::CHECK_ADDRESS_ALIASES_FIELD,
8966        ];
8967    }
8968    impl VerifySignatureRequest {
8969        pub fn path_builder() -> VerifySignatureRequestFieldPathBuilder {
8970            VerifySignatureRequestFieldPathBuilder::new()
8971        }
8972    }
8973    pub struct VerifySignatureRequestFieldPathBuilder {
8974        path: Vec<&'static str>,
8975    }
8976    impl VerifySignatureRequestFieldPathBuilder {
8977        #[allow(clippy::new_without_default)]
8978        pub fn new() -> Self {
8979            Self { path: Default::default() }
8980        }
8981        #[doc(hidden)]
8982        pub fn new_with_base(base: Vec<&'static str>) -> Self {
8983            Self { path: base }
8984        }
8985        pub fn finish(self) -> String {
8986            self.path.join(".")
8987        }
8988        pub fn message(mut self) -> BcsFieldPathBuilder {
8989            self.path.push(VerifySignatureRequest::MESSAGE_FIELD.name);
8990            BcsFieldPathBuilder::new_with_base(self.path)
8991        }
8992        pub fn signature(mut self) -> UserSignatureFieldPathBuilder {
8993            self.path.push(VerifySignatureRequest::SIGNATURE_FIELD.name);
8994            UserSignatureFieldPathBuilder::new_with_base(self.path)
8995        }
8996        pub fn address(mut self) -> String {
8997            self.path.push(VerifySignatureRequest::ADDRESS_FIELD.name);
8998            self.finish()
8999        }
9000        pub fn jwks(mut self) -> ActiveJwkFieldPathBuilder {
9001            self.path.push(VerifySignatureRequest::JWKS_FIELD.name);
9002            ActiveJwkFieldPathBuilder::new_with_base(self.path)
9003        }
9004        pub fn check_address_aliases(mut self) -> String {
9005            self.path.push(VerifySignatureRequest::CHECK_ADDRESS_ALIASES_FIELD.name);
9006            self.finish()
9007        }
9008    }
9009    impl VerifySignatureResponse {
9010        pub const IS_VALID_FIELD: &'static MessageField = &MessageField {
9011            name: "is_valid",
9012            json_name: "isValid",
9013            number: 1i32,
9014            message_fields: None,
9015        };
9016        pub const REASON_FIELD: &'static MessageField = &MessageField {
9017            name: "reason",
9018            json_name: "reason",
9019            number: 2i32,
9020            message_fields: None,
9021        };
9022        pub const ADDRESS_ALIASES_CHECKED_FIELD: &'static MessageField = &MessageField {
9023            name: "address_aliases_checked",
9024            json_name: "addressAliasesChecked",
9025            number: 3i32,
9026            message_fields: None,
9027        };
9028    }
9029    impl MessageFields for VerifySignatureResponse {
9030        const FIELDS: &'static [&'static MessageField] = &[
9031            Self::IS_VALID_FIELD,
9032            Self::REASON_FIELD,
9033            Self::ADDRESS_ALIASES_CHECKED_FIELD,
9034        ];
9035    }
9036    impl VerifySignatureResponse {
9037        pub fn path_builder() -> VerifySignatureResponseFieldPathBuilder {
9038            VerifySignatureResponseFieldPathBuilder::new()
9039        }
9040    }
9041    pub struct VerifySignatureResponseFieldPathBuilder {
9042        path: Vec<&'static str>,
9043    }
9044    impl VerifySignatureResponseFieldPathBuilder {
9045        #[allow(clippy::new_without_default)]
9046        pub fn new() -> Self {
9047            Self { path: Default::default() }
9048        }
9049        #[doc(hidden)]
9050        pub fn new_with_base(base: Vec<&'static str>) -> Self {
9051            Self { path: base }
9052        }
9053        pub fn finish(self) -> String {
9054            self.path.join(".")
9055        }
9056        pub fn is_valid(mut self) -> String {
9057            self.path.push(VerifySignatureResponse::IS_VALID_FIELD.name);
9058            self.finish()
9059        }
9060        pub fn reason(mut self) -> String {
9061            self.path.push(VerifySignatureResponse::REASON_FIELD.name);
9062            self.finish()
9063        }
9064        pub fn address_aliases_checked(mut self) -> String {
9065            self.path.push(VerifySignatureResponse::ADDRESS_ALIASES_CHECKED_FIELD.name);
9066            self.finish()
9067        }
9068    }
9069    impl GetCoinInfoRequest {
9070        pub const COIN_TYPE_FIELD: &'static MessageField = &MessageField {
9071            name: "coin_type",
9072            json_name: "coinType",
9073            number: 1i32,
9074            message_fields: None,
9075        };
9076    }
9077    impl MessageFields for GetCoinInfoRequest {
9078        const FIELDS: &'static [&'static MessageField] = &[Self::COIN_TYPE_FIELD];
9079    }
9080    impl GetCoinInfoRequest {
9081        pub fn path_builder() -> GetCoinInfoRequestFieldPathBuilder {
9082            GetCoinInfoRequestFieldPathBuilder::new()
9083        }
9084    }
9085    pub struct GetCoinInfoRequestFieldPathBuilder {
9086        path: Vec<&'static str>,
9087    }
9088    impl GetCoinInfoRequestFieldPathBuilder {
9089        #[allow(clippy::new_without_default)]
9090        pub fn new() -> Self {
9091            Self { path: Default::default() }
9092        }
9093        #[doc(hidden)]
9094        pub fn new_with_base(base: Vec<&'static str>) -> Self {
9095            Self { path: base }
9096        }
9097        pub fn finish(self) -> String {
9098            self.path.join(".")
9099        }
9100        pub fn coin_type(mut self) -> String {
9101            self.path.push(GetCoinInfoRequest::COIN_TYPE_FIELD.name);
9102            self.finish()
9103        }
9104    }
9105    impl GetCoinInfoResponse {
9106        pub const COIN_TYPE_FIELD: &'static MessageField = &MessageField {
9107            name: "coin_type",
9108            json_name: "coinType",
9109            number: 1i32,
9110            message_fields: None,
9111        };
9112        pub const METADATA_FIELD: &'static MessageField = &MessageField {
9113            name: "metadata",
9114            json_name: "metadata",
9115            number: 2i32,
9116            message_fields: Some(CoinMetadata::FIELDS),
9117        };
9118        pub const TREASURY_FIELD: &'static MessageField = &MessageField {
9119            name: "treasury",
9120            json_name: "treasury",
9121            number: 3i32,
9122            message_fields: Some(CoinTreasury::FIELDS),
9123        };
9124        pub const REGULATED_METADATA_FIELD: &'static MessageField = &MessageField {
9125            name: "regulated_metadata",
9126            json_name: "regulatedMetadata",
9127            number: 4i32,
9128            message_fields: Some(RegulatedCoinMetadata::FIELDS),
9129        };
9130    }
9131    impl MessageFields for GetCoinInfoResponse {
9132        const FIELDS: &'static [&'static MessageField] = &[
9133            Self::COIN_TYPE_FIELD,
9134            Self::METADATA_FIELD,
9135            Self::TREASURY_FIELD,
9136            Self::REGULATED_METADATA_FIELD,
9137        ];
9138    }
9139    impl GetCoinInfoResponse {
9140        pub fn path_builder() -> GetCoinInfoResponseFieldPathBuilder {
9141            GetCoinInfoResponseFieldPathBuilder::new()
9142        }
9143    }
9144    pub struct GetCoinInfoResponseFieldPathBuilder {
9145        path: Vec<&'static str>,
9146    }
9147    impl GetCoinInfoResponseFieldPathBuilder {
9148        #[allow(clippy::new_without_default)]
9149        pub fn new() -> Self {
9150            Self { path: Default::default() }
9151        }
9152        #[doc(hidden)]
9153        pub fn new_with_base(base: Vec<&'static str>) -> Self {
9154            Self { path: base }
9155        }
9156        pub fn finish(self) -> String {
9157            self.path.join(".")
9158        }
9159        pub fn coin_type(mut self) -> String {
9160            self.path.push(GetCoinInfoResponse::COIN_TYPE_FIELD.name);
9161            self.finish()
9162        }
9163        pub fn metadata(mut self) -> CoinMetadataFieldPathBuilder {
9164            self.path.push(GetCoinInfoResponse::METADATA_FIELD.name);
9165            CoinMetadataFieldPathBuilder::new_with_base(self.path)
9166        }
9167        pub fn treasury(mut self) -> CoinTreasuryFieldPathBuilder {
9168            self.path.push(GetCoinInfoResponse::TREASURY_FIELD.name);
9169            CoinTreasuryFieldPathBuilder::new_with_base(self.path)
9170        }
9171        pub fn regulated_metadata(mut self) -> RegulatedCoinMetadataFieldPathBuilder {
9172            self.path.push(GetCoinInfoResponse::REGULATED_METADATA_FIELD.name);
9173            RegulatedCoinMetadataFieldPathBuilder::new_with_base(self.path)
9174        }
9175    }
9176    impl CoinMetadata {
9177        pub const ID_FIELD: &'static MessageField = &MessageField {
9178            name: "id",
9179            json_name: "id",
9180            number: 1i32,
9181            message_fields: None,
9182        };
9183        pub const DECIMALS_FIELD: &'static MessageField = &MessageField {
9184            name: "decimals",
9185            json_name: "decimals",
9186            number: 2i32,
9187            message_fields: None,
9188        };
9189        pub const NAME_FIELD: &'static MessageField = &MessageField {
9190            name: "name",
9191            json_name: "name",
9192            number: 3i32,
9193            message_fields: None,
9194        };
9195        pub const SYMBOL_FIELD: &'static MessageField = &MessageField {
9196            name: "symbol",
9197            json_name: "symbol",
9198            number: 4i32,
9199            message_fields: None,
9200        };
9201        pub const DESCRIPTION_FIELD: &'static MessageField = &MessageField {
9202            name: "description",
9203            json_name: "description",
9204            number: 5i32,
9205            message_fields: None,
9206        };
9207        pub const ICON_URL_FIELD: &'static MessageField = &MessageField {
9208            name: "icon_url",
9209            json_name: "iconUrl",
9210            number: 6i32,
9211            message_fields: None,
9212        };
9213        pub const METADATA_CAP_ID_FIELD: &'static MessageField = &MessageField {
9214            name: "metadata_cap_id",
9215            json_name: "metadataCapId",
9216            number: 7i32,
9217            message_fields: None,
9218        };
9219        pub const METADATA_CAP_STATE_FIELD: &'static MessageField = &MessageField {
9220            name: "metadata_cap_state",
9221            json_name: "metadataCapState",
9222            number: 8i32,
9223            message_fields: None,
9224        };
9225    }
9226    impl MessageFields for CoinMetadata {
9227        const FIELDS: &'static [&'static MessageField] = &[
9228            Self::ID_FIELD,
9229            Self::DECIMALS_FIELD,
9230            Self::NAME_FIELD,
9231            Self::SYMBOL_FIELD,
9232            Self::DESCRIPTION_FIELD,
9233            Self::ICON_URL_FIELD,
9234            Self::METADATA_CAP_ID_FIELD,
9235            Self::METADATA_CAP_STATE_FIELD,
9236        ];
9237    }
9238    impl CoinMetadata {
9239        pub fn path_builder() -> CoinMetadataFieldPathBuilder {
9240            CoinMetadataFieldPathBuilder::new()
9241        }
9242    }
9243    pub struct CoinMetadataFieldPathBuilder {
9244        path: Vec<&'static str>,
9245    }
9246    impl CoinMetadataFieldPathBuilder {
9247        #[allow(clippy::new_without_default)]
9248        pub fn new() -> Self {
9249            Self { path: Default::default() }
9250        }
9251        #[doc(hidden)]
9252        pub fn new_with_base(base: Vec<&'static str>) -> Self {
9253            Self { path: base }
9254        }
9255        pub fn finish(self) -> String {
9256            self.path.join(".")
9257        }
9258        pub fn id(mut self) -> String {
9259            self.path.push(CoinMetadata::ID_FIELD.name);
9260            self.finish()
9261        }
9262        pub fn decimals(mut self) -> String {
9263            self.path.push(CoinMetadata::DECIMALS_FIELD.name);
9264            self.finish()
9265        }
9266        pub fn name(mut self) -> String {
9267            self.path.push(CoinMetadata::NAME_FIELD.name);
9268            self.finish()
9269        }
9270        pub fn symbol(mut self) -> String {
9271            self.path.push(CoinMetadata::SYMBOL_FIELD.name);
9272            self.finish()
9273        }
9274        pub fn description(mut self) -> String {
9275            self.path.push(CoinMetadata::DESCRIPTION_FIELD.name);
9276            self.finish()
9277        }
9278        pub fn icon_url(mut self) -> String {
9279            self.path.push(CoinMetadata::ICON_URL_FIELD.name);
9280            self.finish()
9281        }
9282        pub fn metadata_cap_id(mut self) -> String {
9283            self.path.push(CoinMetadata::METADATA_CAP_ID_FIELD.name);
9284            self.finish()
9285        }
9286        pub fn metadata_cap_state(mut self) -> String {
9287            self.path.push(CoinMetadata::METADATA_CAP_STATE_FIELD.name);
9288            self.finish()
9289        }
9290    }
9291    impl CoinTreasury {
9292        pub const ID_FIELD: &'static MessageField = &MessageField {
9293            name: "id",
9294            json_name: "id",
9295            number: 1i32,
9296            message_fields: None,
9297        };
9298        pub const TOTAL_SUPPLY_FIELD: &'static MessageField = &MessageField {
9299            name: "total_supply",
9300            json_name: "totalSupply",
9301            number: 2i32,
9302            message_fields: None,
9303        };
9304        pub const SUPPLY_STATE_FIELD: &'static MessageField = &MessageField {
9305            name: "supply_state",
9306            json_name: "supplyState",
9307            number: 3i32,
9308            message_fields: None,
9309        };
9310    }
9311    impl MessageFields for CoinTreasury {
9312        const FIELDS: &'static [&'static MessageField] = &[
9313            Self::ID_FIELD,
9314            Self::TOTAL_SUPPLY_FIELD,
9315            Self::SUPPLY_STATE_FIELD,
9316        ];
9317    }
9318    impl CoinTreasury {
9319        pub fn path_builder() -> CoinTreasuryFieldPathBuilder {
9320            CoinTreasuryFieldPathBuilder::new()
9321        }
9322    }
9323    pub struct CoinTreasuryFieldPathBuilder {
9324        path: Vec<&'static str>,
9325    }
9326    impl CoinTreasuryFieldPathBuilder {
9327        #[allow(clippy::new_without_default)]
9328        pub fn new() -> Self {
9329            Self { path: Default::default() }
9330        }
9331        #[doc(hidden)]
9332        pub fn new_with_base(base: Vec<&'static str>) -> Self {
9333            Self { path: base }
9334        }
9335        pub fn finish(self) -> String {
9336            self.path.join(".")
9337        }
9338        pub fn id(mut self) -> String {
9339            self.path.push(CoinTreasury::ID_FIELD.name);
9340            self.finish()
9341        }
9342        pub fn total_supply(mut self) -> String {
9343            self.path.push(CoinTreasury::TOTAL_SUPPLY_FIELD.name);
9344            self.finish()
9345        }
9346        pub fn supply_state(mut self) -> String {
9347            self.path.push(CoinTreasury::SUPPLY_STATE_FIELD.name);
9348            self.finish()
9349        }
9350    }
9351    impl RegulatedCoinMetadata {
9352        pub const ID_FIELD: &'static MessageField = &MessageField {
9353            name: "id",
9354            json_name: "id",
9355            number: 1i32,
9356            message_fields: None,
9357        };
9358        pub const COIN_METADATA_OBJECT_FIELD: &'static MessageField = &MessageField {
9359            name: "coin_metadata_object",
9360            json_name: "coinMetadataObject",
9361            number: 2i32,
9362            message_fields: None,
9363        };
9364        pub const DENY_CAP_OBJECT_FIELD: &'static MessageField = &MessageField {
9365            name: "deny_cap_object",
9366            json_name: "denyCapObject",
9367            number: 3i32,
9368            message_fields: None,
9369        };
9370        pub const ALLOW_GLOBAL_PAUSE_FIELD: &'static MessageField = &MessageField {
9371            name: "allow_global_pause",
9372            json_name: "allowGlobalPause",
9373            number: 4i32,
9374            message_fields: None,
9375        };
9376        pub const VARIANT_FIELD: &'static MessageField = &MessageField {
9377            name: "variant",
9378            json_name: "variant",
9379            number: 5i32,
9380            message_fields: None,
9381        };
9382        pub const COIN_REGULATED_STATE_FIELD: &'static MessageField = &MessageField {
9383            name: "coin_regulated_state",
9384            json_name: "coinRegulatedState",
9385            number: 6i32,
9386            message_fields: None,
9387        };
9388    }
9389    impl MessageFields for RegulatedCoinMetadata {
9390        const FIELDS: &'static [&'static MessageField] = &[
9391            Self::ID_FIELD,
9392            Self::COIN_METADATA_OBJECT_FIELD,
9393            Self::DENY_CAP_OBJECT_FIELD,
9394            Self::ALLOW_GLOBAL_PAUSE_FIELD,
9395            Self::VARIANT_FIELD,
9396            Self::COIN_REGULATED_STATE_FIELD,
9397        ];
9398    }
9399    impl RegulatedCoinMetadata {
9400        pub fn path_builder() -> RegulatedCoinMetadataFieldPathBuilder {
9401            RegulatedCoinMetadataFieldPathBuilder::new()
9402        }
9403    }
9404    pub struct RegulatedCoinMetadataFieldPathBuilder {
9405        path: Vec<&'static str>,
9406    }
9407    impl RegulatedCoinMetadataFieldPathBuilder {
9408        #[allow(clippy::new_without_default)]
9409        pub fn new() -> Self {
9410            Self { path: Default::default() }
9411        }
9412        #[doc(hidden)]
9413        pub fn new_with_base(base: Vec<&'static str>) -> Self {
9414            Self { path: base }
9415        }
9416        pub fn finish(self) -> String {
9417            self.path.join(".")
9418        }
9419        pub fn id(mut self) -> String {
9420            self.path.push(RegulatedCoinMetadata::ID_FIELD.name);
9421            self.finish()
9422        }
9423        pub fn coin_metadata_object(mut self) -> String {
9424            self.path.push(RegulatedCoinMetadata::COIN_METADATA_OBJECT_FIELD.name);
9425            self.finish()
9426        }
9427        pub fn deny_cap_object(mut self) -> String {
9428            self.path.push(RegulatedCoinMetadata::DENY_CAP_OBJECT_FIELD.name);
9429            self.finish()
9430        }
9431        pub fn allow_global_pause(mut self) -> String {
9432            self.path.push(RegulatedCoinMetadata::ALLOW_GLOBAL_PAUSE_FIELD.name);
9433            self.finish()
9434        }
9435        pub fn variant(mut self) -> String {
9436            self.path.push(RegulatedCoinMetadata::VARIANT_FIELD.name);
9437            self.finish()
9438        }
9439        pub fn coin_regulated_state(mut self) -> String {
9440            self.path.push(RegulatedCoinMetadata::COIN_REGULATED_STATE_FIELD.name);
9441            self.finish()
9442        }
9443    }
9444    impl GetBalanceRequest {
9445        pub const OWNER_FIELD: &'static MessageField = &MessageField {
9446            name: "owner",
9447            json_name: "owner",
9448            number: 1i32,
9449            message_fields: None,
9450        };
9451        pub const COIN_TYPE_FIELD: &'static MessageField = &MessageField {
9452            name: "coin_type",
9453            json_name: "coinType",
9454            number: 2i32,
9455            message_fields: None,
9456        };
9457    }
9458    impl MessageFields for GetBalanceRequest {
9459        const FIELDS: &'static [&'static MessageField] = &[
9460            Self::OWNER_FIELD,
9461            Self::COIN_TYPE_FIELD,
9462        ];
9463    }
9464    impl GetBalanceRequest {
9465        pub fn path_builder() -> GetBalanceRequestFieldPathBuilder {
9466            GetBalanceRequestFieldPathBuilder::new()
9467        }
9468    }
9469    pub struct GetBalanceRequestFieldPathBuilder {
9470        path: Vec<&'static str>,
9471    }
9472    impl GetBalanceRequestFieldPathBuilder {
9473        #[allow(clippy::new_without_default)]
9474        pub fn new() -> Self {
9475            Self { path: Default::default() }
9476        }
9477        #[doc(hidden)]
9478        pub fn new_with_base(base: Vec<&'static str>) -> Self {
9479            Self { path: base }
9480        }
9481        pub fn finish(self) -> String {
9482            self.path.join(".")
9483        }
9484        pub fn owner(mut self) -> String {
9485            self.path.push(GetBalanceRequest::OWNER_FIELD.name);
9486            self.finish()
9487        }
9488        pub fn coin_type(mut self) -> String {
9489            self.path.push(GetBalanceRequest::COIN_TYPE_FIELD.name);
9490            self.finish()
9491        }
9492    }
9493    impl GetBalanceResponse {
9494        pub const BALANCE_FIELD: &'static MessageField = &MessageField {
9495            name: "balance",
9496            json_name: "balance",
9497            number: 1i32,
9498            message_fields: Some(Balance::FIELDS),
9499        };
9500    }
9501    impl MessageFields for GetBalanceResponse {
9502        const FIELDS: &'static [&'static MessageField] = &[Self::BALANCE_FIELD];
9503    }
9504    impl GetBalanceResponse {
9505        pub fn path_builder() -> GetBalanceResponseFieldPathBuilder {
9506            GetBalanceResponseFieldPathBuilder::new()
9507        }
9508    }
9509    pub struct GetBalanceResponseFieldPathBuilder {
9510        path: Vec<&'static str>,
9511    }
9512    impl GetBalanceResponseFieldPathBuilder {
9513        #[allow(clippy::new_without_default)]
9514        pub fn new() -> Self {
9515            Self { path: Default::default() }
9516        }
9517        #[doc(hidden)]
9518        pub fn new_with_base(base: Vec<&'static str>) -> Self {
9519            Self { path: base }
9520        }
9521        pub fn finish(self) -> String {
9522            self.path.join(".")
9523        }
9524        pub fn balance(mut self) -> BalanceFieldPathBuilder {
9525            self.path.push(GetBalanceResponse::BALANCE_FIELD.name);
9526            BalanceFieldPathBuilder::new_with_base(self.path)
9527        }
9528    }
9529    impl ListBalancesRequest {
9530        pub const OWNER_FIELD: &'static MessageField = &MessageField {
9531            name: "owner",
9532            json_name: "owner",
9533            number: 1i32,
9534            message_fields: None,
9535        };
9536        pub const PAGE_SIZE_FIELD: &'static MessageField = &MessageField {
9537            name: "page_size",
9538            json_name: "pageSize",
9539            number: 2i32,
9540            message_fields: None,
9541        };
9542        pub const PAGE_TOKEN_FIELD: &'static MessageField = &MessageField {
9543            name: "page_token",
9544            json_name: "pageToken",
9545            number: 3i32,
9546            message_fields: None,
9547        };
9548    }
9549    impl MessageFields for ListBalancesRequest {
9550        const FIELDS: &'static [&'static MessageField] = &[
9551            Self::OWNER_FIELD,
9552            Self::PAGE_SIZE_FIELD,
9553            Self::PAGE_TOKEN_FIELD,
9554        ];
9555    }
9556    impl ListBalancesRequest {
9557        pub fn path_builder() -> ListBalancesRequestFieldPathBuilder {
9558            ListBalancesRequestFieldPathBuilder::new()
9559        }
9560    }
9561    pub struct ListBalancesRequestFieldPathBuilder {
9562        path: Vec<&'static str>,
9563    }
9564    impl ListBalancesRequestFieldPathBuilder {
9565        #[allow(clippy::new_without_default)]
9566        pub fn new() -> Self {
9567            Self { path: Default::default() }
9568        }
9569        #[doc(hidden)]
9570        pub fn new_with_base(base: Vec<&'static str>) -> Self {
9571            Self { path: base }
9572        }
9573        pub fn finish(self) -> String {
9574            self.path.join(".")
9575        }
9576        pub fn owner(mut self) -> String {
9577            self.path.push(ListBalancesRequest::OWNER_FIELD.name);
9578            self.finish()
9579        }
9580        pub fn page_size(mut self) -> String {
9581            self.path.push(ListBalancesRequest::PAGE_SIZE_FIELD.name);
9582            self.finish()
9583        }
9584        pub fn page_token(mut self) -> String {
9585            self.path.push(ListBalancesRequest::PAGE_TOKEN_FIELD.name);
9586            self.finish()
9587        }
9588    }
9589    impl ListBalancesResponse {
9590        pub const BALANCES_FIELD: &'static MessageField = &MessageField {
9591            name: "balances",
9592            json_name: "balances",
9593            number: 1i32,
9594            message_fields: Some(Balance::FIELDS),
9595        };
9596        pub const NEXT_PAGE_TOKEN_FIELD: &'static MessageField = &MessageField {
9597            name: "next_page_token",
9598            json_name: "nextPageToken",
9599            number: 2i32,
9600            message_fields: None,
9601        };
9602    }
9603    impl MessageFields for ListBalancesResponse {
9604        const FIELDS: &'static [&'static MessageField] = &[
9605            Self::BALANCES_FIELD,
9606            Self::NEXT_PAGE_TOKEN_FIELD,
9607        ];
9608    }
9609    impl ListBalancesResponse {
9610        pub fn path_builder() -> ListBalancesResponseFieldPathBuilder {
9611            ListBalancesResponseFieldPathBuilder::new()
9612        }
9613    }
9614    pub struct ListBalancesResponseFieldPathBuilder {
9615        path: Vec<&'static str>,
9616    }
9617    impl ListBalancesResponseFieldPathBuilder {
9618        #[allow(clippy::new_without_default)]
9619        pub fn new() -> Self {
9620            Self { path: Default::default() }
9621        }
9622        #[doc(hidden)]
9623        pub fn new_with_base(base: Vec<&'static str>) -> Self {
9624            Self { path: base }
9625        }
9626        pub fn finish(self) -> String {
9627            self.path.join(".")
9628        }
9629        pub fn balances(mut self) -> BalanceFieldPathBuilder {
9630            self.path.push(ListBalancesResponse::BALANCES_FIELD.name);
9631            BalanceFieldPathBuilder::new_with_base(self.path)
9632        }
9633        pub fn next_page_token(mut self) -> String {
9634            self.path.push(ListBalancesResponse::NEXT_PAGE_TOKEN_FIELD.name);
9635            self.finish()
9636        }
9637    }
9638    impl Balance {
9639        pub const COIN_TYPE_FIELD: &'static MessageField = &MessageField {
9640            name: "coin_type",
9641            json_name: "coinType",
9642            number: 1i32,
9643            message_fields: None,
9644        };
9645        pub const BALANCE_FIELD: &'static MessageField = &MessageField {
9646            name: "balance",
9647            json_name: "balance",
9648            number: 3i32,
9649            message_fields: None,
9650        };
9651        pub const ADDRESS_BALANCE_FIELD: &'static MessageField = &MessageField {
9652            name: "address_balance",
9653            json_name: "addressBalance",
9654            number: 4i32,
9655            message_fields: None,
9656        };
9657        pub const COIN_BALANCE_FIELD: &'static MessageField = &MessageField {
9658            name: "coin_balance",
9659            json_name: "coinBalance",
9660            number: 5i32,
9661            message_fields: None,
9662        };
9663    }
9664    impl MessageFields for Balance {
9665        const FIELDS: &'static [&'static MessageField] = &[
9666            Self::COIN_TYPE_FIELD,
9667            Self::BALANCE_FIELD,
9668            Self::ADDRESS_BALANCE_FIELD,
9669            Self::COIN_BALANCE_FIELD,
9670        ];
9671    }
9672    impl Balance {
9673        pub fn path_builder() -> BalanceFieldPathBuilder {
9674            BalanceFieldPathBuilder::new()
9675        }
9676    }
9677    pub struct BalanceFieldPathBuilder {
9678        path: Vec<&'static str>,
9679    }
9680    impl BalanceFieldPathBuilder {
9681        #[allow(clippy::new_without_default)]
9682        pub fn new() -> Self {
9683            Self { path: Default::default() }
9684        }
9685        #[doc(hidden)]
9686        pub fn new_with_base(base: Vec<&'static str>) -> Self {
9687            Self { path: base }
9688        }
9689        pub fn finish(self) -> String {
9690            self.path.join(".")
9691        }
9692        pub fn coin_type(mut self) -> String {
9693            self.path.push(Balance::COIN_TYPE_FIELD.name);
9694            self.finish()
9695        }
9696        pub fn balance(mut self) -> String {
9697            self.path.push(Balance::BALANCE_FIELD.name);
9698            self.finish()
9699        }
9700        pub fn address_balance(mut self) -> String {
9701            self.path.push(Balance::ADDRESS_BALANCE_FIELD.name);
9702            self.finish()
9703        }
9704        pub fn coin_balance(mut self) -> String {
9705            self.path.push(Balance::COIN_BALANCE_FIELD.name);
9706            self.finish()
9707        }
9708    }
9709    impl ListDynamicFieldsRequest {
9710        pub const PARENT_FIELD: &'static MessageField = &MessageField {
9711            name: "parent",
9712            json_name: "parent",
9713            number: 1i32,
9714            message_fields: None,
9715        };
9716        pub const PAGE_SIZE_FIELD: &'static MessageField = &MessageField {
9717            name: "page_size",
9718            json_name: "pageSize",
9719            number: 2i32,
9720            message_fields: None,
9721        };
9722        pub const PAGE_TOKEN_FIELD: &'static MessageField = &MessageField {
9723            name: "page_token",
9724            json_name: "pageToken",
9725            number: 3i32,
9726            message_fields: None,
9727        };
9728        pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
9729            name: "read_mask",
9730            json_name: "readMask",
9731            number: 4i32,
9732            message_fields: None,
9733        };
9734    }
9735    impl MessageFields for ListDynamicFieldsRequest {
9736        const FIELDS: &'static [&'static MessageField] = &[
9737            Self::PARENT_FIELD,
9738            Self::PAGE_SIZE_FIELD,
9739            Self::PAGE_TOKEN_FIELD,
9740            Self::READ_MASK_FIELD,
9741        ];
9742    }
9743    impl ListDynamicFieldsRequest {
9744        pub fn path_builder() -> ListDynamicFieldsRequestFieldPathBuilder {
9745            ListDynamicFieldsRequestFieldPathBuilder::new()
9746        }
9747    }
9748    pub struct ListDynamicFieldsRequestFieldPathBuilder {
9749        path: Vec<&'static str>,
9750    }
9751    impl ListDynamicFieldsRequestFieldPathBuilder {
9752        #[allow(clippy::new_without_default)]
9753        pub fn new() -> Self {
9754            Self { path: Default::default() }
9755        }
9756        #[doc(hidden)]
9757        pub fn new_with_base(base: Vec<&'static str>) -> Self {
9758            Self { path: base }
9759        }
9760        pub fn finish(self) -> String {
9761            self.path.join(".")
9762        }
9763        pub fn parent(mut self) -> String {
9764            self.path.push(ListDynamicFieldsRequest::PARENT_FIELD.name);
9765            self.finish()
9766        }
9767        pub fn page_size(mut self) -> String {
9768            self.path.push(ListDynamicFieldsRequest::PAGE_SIZE_FIELD.name);
9769            self.finish()
9770        }
9771        pub fn page_token(mut self) -> String {
9772            self.path.push(ListDynamicFieldsRequest::PAGE_TOKEN_FIELD.name);
9773            self.finish()
9774        }
9775        pub fn read_mask(mut self) -> String {
9776            self.path.push(ListDynamicFieldsRequest::READ_MASK_FIELD.name);
9777            self.finish()
9778        }
9779    }
9780    impl ListDynamicFieldsResponse {
9781        pub const DYNAMIC_FIELDS_FIELD: &'static MessageField = &MessageField {
9782            name: "dynamic_fields",
9783            json_name: "dynamicFields",
9784            number: 1i32,
9785            message_fields: Some(DynamicField::FIELDS),
9786        };
9787        pub const NEXT_PAGE_TOKEN_FIELD: &'static MessageField = &MessageField {
9788            name: "next_page_token",
9789            json_name: "nextPageToken",
9790            number: 2i32,
9791            message_fields: None,
9792        };
9793    }
9794    impl MessageFields for ListDynamicFieldsResponse {
9795        const FIELDS: &'static [&'static MessageField] = &[
9796            Self::DYNAMIC_FIELDS_FIELD,
9797            Self::NEXT_PAGE_TOKEN_FIELD,
9798        ];
9799    }
9800    impl ListDynamicFieldsResponse {
9801        pub fn path_builder() -> ListDynamicFieldsResponseFieldPathBuilder {
9802            ListDynamicFieldsResponseFieldPathBuilder::new()
9803        }
9804    }
9805    pub struct ListDynamicFieldsResponseFieldPathBuilder {
9806        path: Vec<&'static str>,
9807    }
9808    impl ListDynamicFieldsResponseFieldPathBuilder {
9809        #[allow(clippy::new_without_default)]
9810        pub fn new() -> Self {
9811            Self { path: Default::default() }
9812        }
9813        #[doc(hidden)]
9814        pub fn new_with_base(base: Vec<&'static str>) -> Self {
9815            Self { path: base }
9816        }
9817        pub fn finish(self) -> String {
9818            self.path.join(".")
9819        }
9820        pub fn dynamic_fields(mut self) -> DynamicFieldFieldPathBuilder {
9821            self.path.push(ListDynamicFieldsResponse::DYNAMIC_FIELDS_FIELD.name);
9822            DynamicFieldFieldPathBuilder::new_with_base(self.path)
9823        }
9824        pub fn next_page_token(mut self) -> String {
9825            self.path.push(ListDynamicFieldsResponse::NEXT_PAGE_TOKEN_FIELD.name);
9826            self.finish()
9827        }
9828    }
9829    impl DynamicField {
9830        pub const KIND_FIELD: &'static MessageField = &MessageField {
9831            name: "kind",
9832            json_name: "kind",
9833            number: 1i32,
9834            message_fields: None,
9835        };
9836        pub const PARENT_FIELD: &'static MessageField = &MessageField {
9837            name: "parent",
9838            json_name: "parent",
9839            number: 2i32,
9840            message_fields: None,
9841        };
9842        pub const FIELD_ID_FIELD: &'static MessageField = &MessageField {
9843            name: "field_id",
9844            json_name: "fieldId",
9845            number: 3i32,
9846            message_fields: None,
9847        };
9848        pub const FIELD_OBJECT_FIELD: &'static MessageField = &MessageField {
9849            name: "field_object",
9850            json_name: "fieldObject",
9851            number: 4i32,
9852            message_fields: Some(Object::FIELDS),
9853        };
9854        pub const NAME_FIELD: &'static MessageField = &MessageField {
9855            name: "name",
9856            json_name: "name",
9857            number: 5i32,
9858            message_fields: Some(Bcs::FIELDS),
9859        };
9860        pub const VALUE_FIELD: &'static MessageField = &MessageField {
9861            name: "value",
9862            json_name: "value",
9863            number: 6i32,
9864            message_fields: Some(Bcs::FIELDS),
9865        };
9866        pub const VALUE_TYPE_FIELD: &'static MessageField = &MessageField {
9867            name: "value_type",
9868            json_name: "valueType",
9869            number: 7i32,
9870            message_fields: None,
9871        };
9872        pub const CHILD_ID_FIELD: &'static MessageField = &MessageField {
9873            name: "child_id",
9874            json_name: "childId",
9875            number: 8i32,
9876            message_fields: None,
9877        };
9878        pub const CHILD_OBJECT_FIELD: &'static MessageField = &MessageField {
9879            name: "child_object",
9880            json_name: "childObject",
9881            number: 9i32,
9882            message_fields: Some(Object::FIELDS),
9883        };
9884    }
9885    impl MessageFields for DynamicField {
9886        const FIELDS: &'static [&'static MessageField] = &[
9887            Self::KIND_FIELD,
9888            Self::PARENT_FIELD,
9889            Self::FIELD_ID_FIELD,
9890            Self::FIELD_OBJECT_FIELD,
9891            Self::NAME_FIELD,
9892            Self::VALUE_FIELD,
9893            Self::VALUE_TYPE_FIELD,
9894            Self::CHILD_ID_FIELD,
9895            Self::CHILD_OBJECT_FIELD,
9896        ];
9897    }
9898    impl DynamicField {
9899        pub fn path_builder() -> DynamicFieldFieldPathBuilder {
9900            DynamicFieldFieldPathBuilder::new()
9901        }
9902    }
9903    pub struct DynamicFieldFieldPathBuilder {
9904        path: Vec<&'static str>,
9905    }
9906    impl DynamicFieldFieldPathBuilder {
9907        #[allow(clippy::new_without_default)]
9908        pub fn new() -> Self {
9909            Self { path: Default::default() }
9910        }
9911        #[doc(hidden)]
9912        pub fn new_with_base(base: Vec<&'static str>) -> Self {
9913            Self { path: base }
9914        }
9915        pub fn finish(self) -> String {
9916            self.path.join(".")
9917        }
9918        pub fn kind(mut self) -> String {
9919            self.path.push(DynamicField::KIND_FIELD.name);
9920            self.finish()
9921        }
9922        pub fn parent(mut self) -> String {
9923            self.path.push(DynamicField::PARENT_FIELD.name);
9924            self.finish()
9925        }
9926        pub fn field_id(mut self) -> String {
9927            self.path.push(DynamicField::FIELD_ID_FIELD.name);
9928            self.finish()
9929        }
9930        pub fn field_object(mut self) -> ObjectFieldPathBuilder {
9931            self.path.push(DynamicField::FIELD_OBJECT_FIELD.name);
9932            ObjectFieldPathBuilder::new_with_base(self.path)
9933        }
9934        pub fn name(mut self) -> BcsFieldPathBuilder {
9935            self.path.push(DynamicField::NAME_FIELD.name);
9936            BcsFieldPathBuilder::new_with_base(self.path)
9937        }
9938        pub fn value(mut self) -> BcsFieldPathBuilder {
9939            self.path.push(DynamicField::VALUE_FIELD.name);
9940            BcsFieldPathBuilder::new_with_base(self.path)
9941        }
9942        pub fn value_type(mut self) -> String {
9943            self.path.push(DynamicField::VALUE_TYPE_FIELD.name);
9944            self.finish()
9945        }
9946        pub fn child_id(mut self) -> String {
9947            self.path.push(DynamicField::CHILD_ID_FIELD.name);
9948            self.finish()
9949        }
9950        pub fn child_object(mut self) -> ObjectFieldPathBuilder {
9951            self.path.push(DynamicField::CHILD_OBJECT_FIELD.name);
9952            ObjectFieldPathBuilder::new_with_base(self.path)
9953        }
9954    }
9955    impl ListOwnedObjectsRequest {
9956        pub const OWNER_FIELD: &'static MessageField = &MessageField {
9957            name: "owner",
9958            json_name: "owner",
9959            number: 1i32,
9960            message_fields: None,
9961        };
9962        pub const PAGE_SIZE_FIELD: &'static MessageField = &MessageField {
9963            name: "page_size",
9964            json_name: "pageSize",
9965            number: 2i32,
9966            message_fields: None,
9967        };
9968        pub const PAGE_TOKEN_FIELD: &'static MessageField = &MessageField {
9969            name: "page_token",
9970            json_name: "pageToken",
9971            number: 3i32,
9972            message_fields: None,
9973        };
9974        pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
9975            name: "read_mask",
9976            json_name: "readMask",
9977            number: 4i32,
9978            message_fields: None,
9979        };
9980        pub const OBJECT_TYPE_FIELD: &'static MessageField = &MessageField {
9981            name: "object_type",
9982            json_name: "objectType",
9983            number: 5i32,
9984            message_fields: None,
9985        };
9986    }
9987    impl MessageFields for ListOwnedObjectsRequest {
9988        const FIELDS: &'static [&'static MessageField] = &[
9989            Self::OWNER_FIELD,
9990            Self::PAGE_SIZE_FIELD,
9991            Self::PAGE_TOKEN_FIELD,
9992            Self::READ_MASK_FIELD,
9993            Self::OBJECT_TYPE_FIELD,
9994        ];
9995    }
9996    impl ListOwnedObjectsRequest {
9997        pub fn path_builder() -> ListOwnedObjectsRequestFieldPathBuilder {
9998            ListOwnedObjectsRequestFieldPathBuilder::new()
9999        }
10000    }
10001    pub struct ListOwnedObjectsRequestFieldPathBuilder {
10002        path: Vec<&'static str>,
10003    }
10004    impl ListOwnedObjectsRequestFieldPathBuilder {
10005        #[allow(clippy::new_without_default)]
10006        pub fn new() -> Self {
10007            Self { path: Default::default() }
10008        }
10009        #[doc(hidden)]
10010        pub fn new_with_base(base: Vec<&'static str>) -> Self {
10011            Self { path: base }
10012        }
10013        pub fn finish(self) -> String {
10014            self.path.join(".")
10015        }
10016        pub fn owner(mut self) -> String {
10017            self.path.push(ListOwnedObjectsRequest::OWNER_FIELD.name);
10018            self.finish()
10019        }
10020        pub fn page_size(mut self) -> String {
10021            self.path.push(ListOwnedObjectsRequest::PAGE_SIZE_FIELD.name);
10022            self.finish()
10023        }
10024        pub fn page_token(mut self) -> String {
10025            self.path.push(ListOwnedObjectsRequest::PAGE_TOKEN_FIELD.name);
10026            self.finish()
10027        }
10028        pub fn read_mask(mut self) -> String {
10029            self.path.push(ListOwnedObjectsRequest::READ_MASK_FIELD.name);
10030            self.finish()
10031        }
10032        pub fn object_type(mut self) -> String {
10033            self.path.push(ListOwnedObjectsRequest::OBJECT_TYPE_FIELD.name);
10034            self.finish()
10035        }
10036    }
10037    impl ListOwnedObjectsResponse {
10038        pub const OBJECTS_FIELD: &'static MessageField = &MessageField {
10039            name: "objects",
10040            json_name: "objects",
10041            number: 1i32,
10042            message_fields: Some(Object::FIELDS),
10043        };
10044        pub const NEXT_PAGE_TOKEN_FIELD: &'static MessageField = &MessageField {
10045            name: "next_page_token",
10046            json_name: "nextPageToken",
10047            number: 2i32,
10048            message_fields: None,
10049        };
10050    }
10051    impl MessageFields for ListOwnedObjectsResponse {
10052        const FIELDS: &'static [&'static MessageField] = &[
10053            Self::OBJECTS_FIELD,
10054            Self::NEXT_PAGE_TOKEN_FIELD,
10055        ];
10056    }
10057    impl ListOwnedObjectsResponse {
10058        pub fn path_builder() -> ListOwnedObjectsResponseFieldPathBuilder {
10059            ListOwnedObjectsResponseFieldPathBuilder::new()
10060        }
10061    }
10062    pub struct ListOwnedObjectsResponseFieldPathBuilder {
10063        path: Vec<&'static str>,
10064    }
10065    impl ListOwnedObjectsResponseFieldPathBuilder {
10066        #[allow(clippy::new_without_default)]
10067        pub fn new() -> Self {
10068            Self { path: Default::default() }
10069        }
10070        #[doc(hidden)]
10071        pub fn new_with_base(base: Vec<&'static str>) -> Self {
10072            Self { path: base }
10073        }
10074        pub fn finish(self) -> String {
10075            self.path.join(".")
10076        }
10077        pub fn objects(mut self) -> ObjectFieldPathBuilder {
10078            self.path.push(ListOwnedObjectsResponse::OBJECTS_FIELD.name);
10079            ObjectFieldPathBuilder::new_with_base(self.path)
10080        }
10081        pub fn next_page_token(mut self) -> String {
10082            self.path.push(ListOwnedObjectsResponse::NEXT_PAGE_TOKEN_FIELD.name);
10083            self.finish()
10084        }
10085    }
10086    impl SubscribeCheckpointsRequest {
10087        pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
10088            name: "read_mask",
10089            json_name: "readMask",
10090            number: 1i32,
10091            message_fields: None,
10092        };
10093        pub const FILTER_FIELD: &'static MessageField = &MessageField {
10094            name: "filter",
10095            json_name: "filter",
10096            number: 2i32,
10097            message_fields: Some(TransactionFilter::FIELDS),
10098        };
10099    }
10100    impl MessageFields for SubscribeCheckpointsRequest {
10101        const FIELDS: &'static [&'static MessageField] = &[
10102            Self::READ_MASK_FIELD,
10103            Self::FILTER_FIELD,
10104        ];
10105    }
10106    impl SubscribeCheckpointsRequest {
10107        pub fn path_builder() -> SubscribeCheckpointsRequestFieldPathBuilder {
10108            SubscribeCheckpointsRequestFieldPathBuilder::new()
10109        }
10110    }
10111    pub struct SubscribeCheckpointsRequestFieldPathBuilder {
10112        path: Vec<&'static str>,
10113    }
10114    impl SubscribeCheckpointsRequestFieldPathBuilder {
10115        #[allow(clippy::new_without_default)]
10116        pub fn new() -> Self {
10117            Self { path: Default::default() }
10118        }
10119        #[doc(hidden)]
10120        pub fn new_with_base(base: Vec<&'static str>) -> Self {
10121            Self { path: base }
10122        }
10123        pub fn finish(self) -> String {
10124            self.path.join(".")
10125        }
10126        pub fn read_mask(mut self) -> String {
10127            self.path.push(SubscribeCheckpointsRequest::READ_MASK_FIELD.name);
10128            self.finish()
10129        }
10130        pub fn filter(mut self) -> TransactionFilterFieldPathBuilder {
10131            self.path.push(SubscribeCheckpointsRequest::FILTER_FIELD.name);
10132            TransactionFilterFieldPathBuilder::new_with_base(self.path)
10133        }
10134    }
10135    impl SubscribeCheckpointsResponse {
10136        pub const CURSOR_FIELD: &'static MessageField = &MessageField {
10137            name: "cursor",
10138            json_name: "cursor",
10139            number: 1i32,
10140            message_fields: None,
10141        };
10142        pub const CHECKPOINT_FIELD: &'static MessageField = &MessageField {
10143            name: "checkpoint",
10144            json_name: "checkpoint",
10145            number: 2i32,
10146            message_fields: Some(Checkpoint::FIELDS),
10147        };
10148    }
10149    impl MessageFields for SubscribeCheckpointsResponse {
10150        const FIELDS: &'static [&'static MessageField] = &[
10151            Self::CURSOR_FIELD,
10152            Self::CHECKPOINT_FIELD,
10153        ];
10154    }
10155    impl SubscribeCheckpointsResponse {
10156        pub fn path_builder() -> SubscribeCheckpointsResponseFieldPathBuilder {
10157            SubscribeCheckpointsResponseFieldPathBuilder::new()
10158        }
10159    }
10160    pub struct SubscribeCheckpointsResponseFieldPathBuilder {
10161        path: Vec<&'static str>,
10162    }
10163    impl SubscribeCheckpointsResponseFieldPathBuilder {
10164        #[allow(clippy::new_without_default)]
10165        pub fn new() -> Self {
10166            Self { path: Default::default() }
10167        }
10168        #[doc(hidden)]
10169        pub fn new_with_base(base: Vec<&'static str>) -> Self {
10170            Self { path: base }
10171        }
10172        pub fn finish(self) -> String {
10173            self.path.join(".")
10174        }
10175        pub fn cursor(mut self) -> String {
10176            self.path.push(SubscribeCheckpointsResponse::CURSOR_FIELD.name);
10177            self.finish()
10178        }
10179        pub fn checkpoint(mut self) -> CheckpointFieldPathBuilder {
10180            self.path.push(SubscribeCheckpointsResponse::CHECKPOINT_FIELD.name);
10181            CheckpointFieldPathBuilder::new_with_base(self.path)
10182        }
10183    }
10184    impl SubscribeTransactionsRequest {
10185        pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
10186            name: "read_mask",
10187            json_name: "readMask",
10188            number: 1i32,
10189            message_fields: None,
10190        };
10191        pub const FILTER_FIELD: &'static MessageField = &MessageField {
10192            name: "filter",
10193            json_name: "filter",
10194            number: 2i32,
10195            message_fields: Some(TransactionFilter::FIELDS),
10196        };
10197    }
10198    impl MessageFields for SubscribeTransactionsRequest {
10199        const FIELDS: &'static [&'static MessageField] = &[
10200            Self::READ_MASK_FIELD,
10201            Self::FILTER_FIELD,
10202        ];
10203    }
10204    impl SubscribeTransactionsRequest {
10205        pub fn path_builder() -> SubscribeTransactionsRequestFieldPathBuilder {
10206            SubscribeTransactionsRequestFieldPathBuilder::new()
10207        }
10208    }
10209    pub struct SubscribeTransactionsRequestFieldPathBuilder {
10210        path: Vec<&'static str>,
10211    }
10212    impl SubscribeTransactionsRequestFieldPathBuilder {
10213        #[allow(clippy::new_without_default)]
10214        pub fn new() -> Self {
10215            Self { path: Default::default() }
10216        }
10217        #[doc(hidden)]
10218        pub fn new_with_base(base: Vec<&'static str>) -> Self {
10219            Self { path: base }
10220        }
10221        pub fn finish(self) -> String {
10222            self.path.join(".")
10223        }
10224        pub fn read_mask(mut self) -> String {
10225            self.path.push(SubscribeTransactionsRequest::READ_MASK_FIELD.name);
10226            self.finish()
10227        }
10228        pub fn filter(mut self) -> TransactionFilterFieldPathBuilder {
10229            self.path.push(SubscribeTransactionsRequest::FILTER_FIELD.name);
10230            TransactionFilterFieldPathBuilder::new_with_base(self.path)
10231        }
10232    }
10233    impl SubscribeTransactionsResponse {
10234        pub const TRANSACTION_FIELD: &'static MessageField = &MessageField {
10235            name: "transaction",
10236            json_name: "transaction",
10237            number: 1i32,
10238            message_fields: Some(ExecutedTransaction::FIELDS),
10239        };
10240        pub const WATERMARK_FIELD: &'static MessageField = &MessageField {
10241            name: "watermark",
10242            json_name: "watermark",
10243            number: 2i32,
10244            message_fields: Some(Watermark::FIELDS),
10245        };
10246    }
10247    impl MessageFields for SubscribeTransactionsResponse {
10248        const FIELDS: &'static [&'static MessageField] = &[
10249            Self::TRANSACTION_FIELD,
10250            Self::WATERMARK_FIELD,
10251        ];
10252    }
10253    impl SubscribeTransactionsResponse {
10254        pub fn path_builder() -> SubscribeTransactionsResponseFieldPathBuilder {
10255            SubscribeTransactionsResponseFieldPathBuilder::new()
10256        }
10257    }
10258    pub struct SubscribeTransactionsResponseFieldPathBuilder {
10259        path: Vec<&'static str>,
10260    }
10261    impl SubscribeTransactionsResponseFieldPathBuilder {
10262        #[allow(clippy::new_without_default)]
10263        pub fn new() -> Self {
10264            Self { path: Default::default() }
10265        }
10266        #[doc(hidden)]
10267        pub fn new_with_base(base: Vec<&'static str>) -> Self {
10268            Self { path: base }
10269        }
10270        pub fn finish(self) -> String {
10271            self.path.join(".")
10272        }
10273        pub fn transaction(mut self) -> ExecutedTransactionFieldPathBuilder {
10274            self.path.push(SubscribeTransactionsResponse::TRANSACTION_FIELD.name);
10275            ExecutedTransactionFieldPathBuilder::new_with_base(self.path)
10276        }
10277        pub fn watermark(mut self) -> WatermarkFieldPathBuilder {
10278            self.path.push(SubscribeTransactionsResponse::WATERMARK_FIELD.name);
10279            WatermarkFieldPathBuilder::new_with_base(self.path)
10280        }
10281    }
10282    impl SubscribeEventsRequest {
10283        pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
10284            name: "read_mask",
10285            json_name: "readMask",
10286            number: 1i32,
10287            message_fields: None,
10288        };
10289        pub const FILTER_FIELD: &'static MessageField = &MessageField {
10290            name: "filter",
10291            json_name: "filter",
10292            number: 2i32,
10293            message_fields: Some(EventFilter::FIELDS),
10294        };
10295    }
10296    impl MessageFields for SubscribeEventsRequest {
10297        const FIELDS: &'static [&'static MessageField] = &[
10298            Self::READ_MASK_FIELD,
10299            Self::FILTER_FIELD,
10300        ];
10301    }
10302    impl SubscribeEventsRequest {
10303        pub fn path_builder() -> SubscribeEventsRequestFieldPathBuilder {
10304            SubscribeEventsRequestFieldPathBuilder::new()
10305        }
10306    }
10307    pub struct SubscribeEventsRequestFieldPathBuilder {
10308        path: Vec<&'static str>,
10309    }
10310    impl SubscribeEventsRequestFieldPathBuilder {
10311        #[allow(clippy::new_without_default)]
10312        pub fn new() -> Self {
10313            Self { path: Default::default() }
10314        }
10315        #[doc(hidden)]
10316        pub fn new_with_base(base: Vec<&'static str>) -> Self {
10317            Self { path: base }
10318        }
10319        pub fn finish(self) -> String {
10320            self.path.join(".")
10321        }
10322        pub fn read_mask(mut self) -> String {
10323            self.path.push(SubscribeEventsRequest::READ_MASK_FIELD.name);
10324            self.finish()
10325        }
10326        pub fn filter(mut self) -> EventFilterFieldPathBuilder {
10327            self.path.push(SubscribeEventsRequest::FILTER_FIELD.name);
10328            EventFilterFieldPathBuilder::new_with_base(self.path)
10329        }
10330    }
10331    impl SubscribeEventsResponse {
10332        pub const EVENT_FIELD: &'static MessageField = &MessageField {
10333            name: "event",
10334            json_name: "event",
10335            number: 1i32,
10336            message_fields: Some(Event::FIELDS),
10337        };
10338        pub const WATERMARK_FIELD: &'static MessageField = &MessageField {
10339            name: "watermark",
10340            json_name: "watermark",
10341            number: 2i32,
10342            message_fields: Some(Watermark::FIELDS),
10343        };
10344    }
10345    impl MessageFields for SubscribeEventsResponse {
10346        const FIELDS: &'static [&'static MessageField] = &[
10347            Self::EVENT_FIELD,
10348            Self::WATERMARK_FIELD,
10349        ];
10350    }
10351    impl SubscribeEventsResponse {
10352        pub fn path_builder() -> SubscribeEventsResponseFieldPathBuilder {
10353            SubscribeEventsResponseFieldPathBuilder::new()
10354        }
10355    }
10356    pub struct SubscribeEventsResponseFieldPathBuilder {
10357        path: Vec<&'static str>,
10358    }
10359    impl SubscribeEventsResponseFieldPathBuilder {
10360        #[allow(clippy::new_without_default)]
10361        pub fn new() -> Self {
10362            Self { path: Default::default() }
10363        }
10364        #[doc(hidden)]
10365        pub fn new_with_base(base: Vec<&'static str>) -> Self {
10366            Self { path: base }
10367        }
10368        pub fn finish(self) -> String {
10369            self.path.join(".")
10370        }
10371        pub fn event(mut self) -> EventFieldPathBuilder {
10372            self.path.push(SubscribeEventsResponse::EVENT_FIELD.name);
10373            EventFieldPathBuilder::new_with_base(self.path)
10374        }
10375        pub fn watermark(mut self) -> WatermarkFieldPathBuilder {
10376            self.path.push(SubscribeEventsResponse::WATERMARK_FIELD.name);
10377            WatermarkFieldPathBuilder::new_with_base(self.path)
10378        }
10379    }
10380    impl SystemState {
10381        pub const VERSION_FIELD: &'static MessageField = &MessageField {
10382            name: "version",
10383            json_name: "version",
10384            number: 1i32,
10385            message_fields: None,
10386        };
10387        pub const EPOCH_FIELD: &'static MessageField = &MessageField {
10388            name: "epoch",
10389            json_name: "epoch",
10390            number: 2i32,
10391            message_fields: None,
10392        };
10393        pub const PROTOCOL_VERSION_FIELD: &'static MessageField = &MessageField {
10394            name: "protocol_version",
10395            json_name: "protocolVersion",
10396            number: 3i32,
10397            message_fields: None,
10398        };
10399        pub const VALIDATORS_FIELD: &'static MessageField = &MessageField {
10400            name: "validators",
10401            json_name: "validators",
10402            number: 4i32,
10403            message_fields: Some(ValidatorSet::FIELDS),
10404        };
10405        pub const STORAGE_FUND_FIELD: &'static MessageField = &MessageField {
10406            name: "storage_fund",
10407            json_name: "storageFund",
10408            number: 5i32,
10409            message_fields: Some(StorageFund::FIELDS),
10410        };
10411        pub const PARAMETERS_FIELD: &'static MessageField = &MessageField {
10412            name: "parameters",
10413            json_name: "parameters",
10414            number: 6i32,
10415            message_fields: Some(SystemParameters::FIELDS),
10416        };
10417        pub const REFERENCE_GAS_PRICE_FIELD: &'static MessageField = &MessageField {
10418            name: "reference_gas_price",
10419            json_name: "referenceGasPrice",
10420            number: 7i32,
10421            message_fields: None,
10422        };
10423        pub const VALIDATOR_REPORT_RECORDS_FIELD: &'static MessageField = &MessageField {
10424            name: "validator_report_records",
10425            json_name: "validatorReportRecords",
10426            number: 8i32,
10427            message_fields: Some(ValidatorReportRecord::FIELDS),
10428        };
10429        pub const STAKE_SUBSIDY_FIELD: &'static MessageField = &MessageField {
10430            name: "stake_subsidy",
10431            json_name: "stakeSubsidy",
10432            number: 9i32,
10433            message_fields: Some(StakeSubsidy::FIELDS),
10434        };
10435        pub const SAFE_MODE_FIELD: &'static MessageField = &MessageField {
10436            name: "safe_mode",
10437            json_name: "safeMode",
10438            number: 10i32,
10439            message_fields: None,
10440        };
10441        pub const SAFE_MODE_STORAGE_REWARDS_FIELD: &'static MessageField = &MessageField {
10442            name: "safe_mode_storage_rewards",
10443            json_name: "safeModeStorageRewards",
10444            number: 11i32,
10445            message_fields: None,
10446        };
10447        pub const SAFE_MODE_COMPUTATION_REWARDS_FIELD: &'static MessageField = &MessageField {
10448            name: "safe_mode_computation_rewards",
10449            json_name: "safeModeComputationRewards",
10450            number: 12i32,
10451            message_fields: None,
10452        };
10453        pub const SAFE_MODE_STORAGE_REBATES_FIELD: &'static MessageField = &MessageField {
10454            name: "safe_mode_storage_rebates",
10455            json_name: "safeModeStorageRebates",
10456            number: 13i32,
10457            message_fields: None,
10458        };
10459        pub const SAFE_MODE_NON_REFUNDABLE_STORAGE_FEE_FIELD: &'static MessageField = &MessageField {
10460            name: "safe_mode_non_refundable_storage_fee",
10461            json_name: "safeModeNonRefundableStorageFee",
10462            number: 14i32,
10463            message_fields: None,
10464        };
10465        pub const EPOCH_START_TIMESTAMP_MS_FIELD: &'static MessageField = &MessageField {
10466            name: "epoch_start_timestamp_ms",
10467            json_name: "epochStartTimestampMs",
10468            number: 15i32,
10469            message_fields: None,
10470        };
10471        pub const EXTRA_FIELDS_FIELD: &'static MessageField = &MessageField {
10472            name: "extra_fields",
10473            json_name: "extraFields",
10474            number: 16i32,
10475            message_fields: Some(MoveTable::FIELDS),
10476        };
10477    }
10478    impl MessageFields for SystemState {
10479        const FIELDS: &'static [&'static MessageField] = &[
10480            Self::VERSION_FIELD,
10481            Self::EPOCH_FIELD,
10482            Self::PROTOCOL_VERSION_FIELD,
10483            Self::VALIDATORS_FIELD,
10484            Self::STORAGE_FUND_FIELD,
10485            Self::PARAMETERS_FIELD,
10486            Self::REFERENCE_GAS_PRICE_FIELD,
10487            Self::VALIDATOR_REPORT_RECORDS_FIELD,
10488            Self::STAKE_SUBSIDY_FIELD,
10489            Self::SAFE_MODE_FIELD,
10490            Self::SAFE_MODE_STORAGE_REWARDS_FIELD,
10491            Self::SAFE_MODE_COMPUTATION_REWARDS_FIELD,
10492            Self::SAFE_MODE_STORAGE_REBATES_FIELD,
10493            Self::SAFE_MODE_NON_REFUNDABLE_STORAGE_FEE_FIELD,
10494            Self::EPOCH_START_TIMESTAMP_MS_FIELD,
10495            Self::EXTRA_FIELDS_FIELD,
10496        ];
10497    }
10498    impl SystemState {
10499        pub fn path_builder() -> SystemStateFieldPathBuilder {
10500            SystemStateFieldPathBuilder::new()
10501        }
10502    }
10503    pub struct SystemStateFieldPathBuilder {
10504        path: Vec<&'static str>,
10505    }
10506    impl SystemStateFieldPathBuilder {
10507        #[allow(clippy::new_without_default)]
10508        pub fn new() -> Self {
10509            Self { path: Default::default() }
10510        }
10511        #[doc(hidden)]
10512        pub fn new_with_base(base: Vec<&'static str>) -> Self {
10513            Self { path: base }
10514        }
10515        pub fn finish(self) -> String {
10516            self.path.join(".")
10517        }
10518        pub fn version(mut self) -> String {
10519            self.path.push(SystemState::VERSION_FIELD.name);
10520            self.finish()
10521        }
10522        pub fn epoch(mut self) -> String {
10523            self.path.push(SystemState::EPOCH_FIELD.name);
10524            self.finish()
10525        }
10526        pub fn protocol_version(mut self) -> String {
10527            self.path.push(SystemState::PROTOCOL_VERSION_FIELD.name);
10528            self.finish()
10529        }
10530        pub fn validators(mut self) -> ValidatorSetFieldPathBuilder {
10531            self.path.push(SystemState::VALIDATORS_FIELD.name);
10532            ValidatorSetFieldPathBuilder::new_with_base(self.path)
10533        }
10534        pub fn storage_fund(mut self) -> StorageFundFieldPathBuilder {
10535            self.path.push(SystemState::STORAGE_FUND_FIELD.name);
10536            StorageFundFieldPathBuilder::new_with_base(self.path)
10537        }
10538        pub fn parameters(mut self) -> SystemParametersFieldPathBuilder {
10539            self.path.push(SystemState::PARAMETERS_FIELD.name);
10540            SystemParametersFieldPathBuilder::new_with_base(self.path)
10541        }
10542        pub fn reference_gas_price(mut self) -> String {
10543            self.path.push(SystemState::REFERENCE_GAS_PRICE_FIELD.name);
10544            self.finish()
10545        }
10546        pub fn validator_report_records(
10547            mut self,
10548        ) -> ValidatorReportRecordFieldPathBuilder {
10549            self.path.push(SystemState::VALIDATOR_REPORT_RECORDS_FIELD.name);
10550            ValidatorReportRecordFieldPathBuilder::new_with_base(self.path)
10551        }
10552        pub fn stake_subsidy(mut self) -> StakeSubsidyFieldPathBuilder {
10553            self.path.push(SystemState::STAKE_SUBSIDY_FIELD.name);
10554            StakeSubsidyFieldPathBuilder::new_with_base(self.path)
10555        }
10556        pub fn safe_mode(mut self) -> String {
10557            self.path.push(SystemState::SAFE_MODE_FIELD.name);
10558            self.finish()
10559        }
10560        pub fn safe_mode_storage_rewards(mut self) -> String {
10561            self.path.push(SystemState::SAFE_MODE_STORAGE_REWARDS_FIELD.name);
10562            self.finish()
10563        }
10564        pub fn safe_mode_computation_rewards(mut self) -> String {
10565            self.path.push(SystemState::SAFE_MODE_COMPUTATION_REWARDS_FIELD.name);
10566            self.finish()
10567        }
10568        pub fn safe_mode_storage_rebates(mut self) -> String {
10569            self.path.push(SystemState::SAFE_MODE_STORAGE_REBATES_FIELD.name);
10570            self.finish()
10571        }
10572        pub fn safe_mode_non_refundable_storage_fee(mut self) -> String {
10573            self.path.push(SystemState::SAFE_MODE_NON_REFUNDABLE_STORAGE_FEE_FIELD.name);
10574            self.finish()
10575        }
10576        pub fn epoch_start_timestamp_ms(mut self) -> String {
10577            self.path.push(SystemState::EPOCH_START_TIMESTAMP_MS_FIELD.name);
10578            self.finish()
10579        }
10580        pub fn extra_fields(mut self) -> MoveTableFieldPathBuilder {
10581            self.path.push(SystemState::EXTRA_FIELDS_FIELD.name);
10582            MoveTableFieldPathBuilder::new_with_base(self.path)
10583        }
10584    }
10585    impl ValidatorReportRecord {
10586        pub const REPORTED_FIELD: &'static MessageField = &MessageField {
10587            name: "reported",
10588            json_name: "reported",
10589            number: 1i32,
10590            message_fields: None,
10591        };
10592        pub const REPORTERS_FIELD: &'static MessageField = &MessageField {
10593            name: "reporters",
10594            json_name: "reporters",
10595            number: 2i32,
10596            message_fields: None,
10597        };
10598    }
10599    impl MessageFields for ValidatorReportRecord {
10600        const FIELDS: &'static [&'static MessageField] = &[
10601            Self::REPORTED_FIELD,
10602            Self::REPORTERS_FIELD,
10603        ];
10604    }
10605    impl ValidatorReportRecord {
10606        pub fn path_builder() -> ValidatorReportRecordFieldPathBuilder {
10607            ValidatorReportRecordFieldPathBuilder::new()
10608        }
10609    }
10610    pub struct ValidatorReportRecordFieldPathBuilder {
10611        path: Vec<&'static str>,
10612    }
10613    impl ValidatorReportRecordFieldPathBuilder {
10614        #[allow(clippy::new_without_default)]
10615        pub fn new() -> Self {
10616            Self { path: Default::default() }
10617        }
10618        #[doc(hidden)]
10619        pub fn new_with_base(base: Vec<&'static str>) -> Self {
10620            Self { path: base }
10621        }
10622        pub fn finish(self) -> String {
10623            self.path.join(".")
10624        }
10625        pub fn reported(mut self) -> String {
10626            self.path.push(ValidatorReportRecord::REPORTED_FIELD.name);
10627            self.finish()
10628        }
10629        pub fn reporters(mut self) -> String {
10630            self.path.push(ValidatorReportRecord::REPORTERS_FIELD.name);
10631            self.finish()
10632        }
10633    }
10634    impl SystemParameters {
10635        pub const EPOCH_DURATION_MS_FIELD: &'static MessageField = &MessageField {
10636            name: "epoch_duration_ms",
10637            json_name: "epochDurationMs",
10638            number: 1i32,
10639            message_fields: None,
10640        };
10641        pub const STAKE_SUBSIDY_START_EPOCH_FIELD: &'static MessageField = &MessageField {
10642            name: "stake_subsidy_start_epoch",
10643            json_name: "stakeSubsidyStartEpoch",
10644            number: 2i32,
10645            message_fields: None,
10646        };
10647        pub const MIN_VALIDATOR_COUNT_FIELD: &'static MessageField = &MessageField {
10648            name: "min_validator_count",
10649            json_name: "minValidatorCount",
10650            number: 3i32,
10651            message_fields: None,
10652        };
10653        pub const MAX_VALIDATOR_COUNT_FIELD: &'static MessageField = &MessageField {
10654            name: "max_validator_count",
10655            json_name: "maxValidatorCount",
10656            number: 4i32,
10657            message_fields: None,
10658        };
10659        pub const MIN_VALIDATOR_JOINING_STAKE_FIELD: &'static MessageField = &MessageField {
10660            name: "min_validator_joining_stake",
10661            json_name: "minValidatorJoiningStake",
10662            number: 5i32,
10663            message_fields: None,
10664        };
10665        pub const VALIDATOR_LOW_STAKE_THRESHOLD_FIELD: &'static MessageField = &MessageField {
10666            name: "validator_low_stake_threshold",
10667            json_name: "validatorLowStakeThreshold",
10668            number: 6i32,
10669            message_fields: None,
10670        };
10671        pub const VALIDATOR_VERY_LOW_STAKE_THRESHOLD_FIELD: &'static MessageField = &MessageField {
10672            name: "validator_very_low_stake_threshold",
10673            json_name: "validatorVeryLowStakeThreshold",
10674            number: 7i32,
10675            message_fields: None,
10676        };
10677        pub const VALIDATOR_LOW_STAKE_GRACE_PERIOD_FIELD: &'static MessageField = &MessageField {
10678            name: "validator_low_stake_grace_period",
10679            json_name: "validatorLowStakeGracePeriod",
10680            number: 8i32,
10681            message_fields: None,
10682        };
10683        pub const EXTRA_FIELDS_FIELD: &'static MessageField = &MessageField {
10684            name: "extra_fields",
10685            json_name: "extraFields",
10686            number: 9i32,
10687            message_fields: Some(MoveTable::FIELDS),
10688        };
10689    }
10690    impl MessageFields for SystemParameters {
10691        const FIELDS: &'static [&'static MessageField] = &[
10692            Self::EPOCH_DURATION_MS_FIELD,
10693            Self::STAKE_SUBSIDY_START_EPOCH_FIELD,
10694            Self::MIN_VALIDATOR_COUNT_FIELD,
10695            Self::MAX_VALIDATOR_COUNT_FIELD,
10696            Self::MIN_VALIDATOR_JOINING_STAKE_FIELD,
10697            Self::VALIDATOR_LOW_STAKE_THRESHOLD_FIELD,
10698            Self::VALIDATOR_VERY_LOW_STAKE_THRESHOLD_FIELD,
10699            Self::VALIDATOR_LOW_STAKE_GRACE_PERIOD_FIELD,
10700            Self::EXTRA_FIELDS_FIELD,
10701        ];
10702    }
10703    impl SystemParameters {
10704        pub fn path_builder() -> SystemParametersFieldPathBuilder {
10705            SystemParametersFieldPathBuilder::new()
10706        }
10707    }
10708    pub struct SystemParametersFieldPathBuilder {
10709        path: Vec<&'static str>,
10710    }
10711    impl SystemParametersFieldPathBuilder {
10712        #[allow(clippy::new_without_default)]
10713        pub fn new() -> Self {
10714            Self { path: Default::default() }
10715        }
10716        #[doc(hidden)]
10717        pub fn new_with_base(base: Vec<&'static str>) -> Self {
10718            Self { path: base }
10719        }
10720        pub fn finish(self) -> String {
10721            self.path.join(".")
10722        }
10723        pub fn epoch_duration_ms(mut self) -> String {
10724            self.path.push(SystemParameters::EPOCH_DURATION_MS_FIELD.name);
10725            self.finish()
10726        }
10727        pub fn stake_subsidy_start_epoch(mut self) -> String {
10728            self.path.push(SystemParameters::STAKE_SUBSIDY_START_EPOCH_FIELD.name);
10729            self.finish()
10730        }
10731        pub fn min_validator_count(mut self) -> String {
10732            self.path.push(SystemParameters::MIN_VALIDATOR_COUNT_FIELD.name);
10733            self.finish()
10734        }
10735        pub fn max_validator_count(mut self) -> String {
10736            self.path.push(SystemParameters::MAX_VALIDATOR_COUNT_FIELD.name);
10737            self.finish()
10738        }
10739        pub fn min_validator_joining_stake(mut self) -> String {
10740            self.path.push(SystemParameters::MIN_VALIDATOR_JOINING_STAKE_FIELD.name);
10741            self.finish()
10742        }
10743        pub fn validator_low_stake_threshold(mut self) -> String {
10744            self.path.push(SystemParameters::VALIDATOR_LOW_STAKE_THRESHOLD_FIELD.name);
10745            self.finish()
10746        }
10747        pub fn validator_very_low_stake_threshold(mut self) -> String {
10748            self.path
10749                .push(SystemParameters::VALIDATOR_VERY_LOW_STAKE_THRESHOLD_FIELD.name);
10750            self.finish()
10751        }
10752        pub fn validator_low_stake_grace_period(mut self) -> String {
10753            self.path
10754                .push(SystemParameters::VALIDATOR_LOW_STAKE_GRACE_PERIOD_FIELD.name);
10755            self.finish()
10756        }
10757        pub fn extra_fields(mut self) -> MoveTableFieldPathBuilder {
10758            self.path.push(SystemParameters::EXTRA_FIELDS_FIELD.name);
10759            MoveTableFieldPathBuilder::new_with_base(self.path)
10760        }
10761    }
10762    impl MoveTable {
10763        pub const ID_FIELD: &'static MessageField = &MessageField {
10764            name: "id",
10765            json_name: "id",
10766            number: 1i32,
10767            message_fields: None,
10768        };
10769        pub const SIZE_FIELD: &'static MessageField = &MessageField {
10770            name: "size",
10771            json_name: "size",
10772            number: 2i32,
10773            message_fields: None,
10774        };
10775    }
10776    impl MessageFields for MoveTable {
10777        const FIELDS: &'static [&'static MessageField] = &[
10778            Self::ID_FIELD,
10779            Self::SIZE_FIELD,
10780        ];
10781    }
10782    impl MoveTable {
10783        pub fn path_builder() -> MoveTableFieldPathBuilder {
10784            MoveTableFieldPathBuilder::new()
10785        }
10786    }
10787    pub struct MoveTableFieldPathBuilder {
10788        path: Vec<&'static str>,
10789    }
10790    impl MoveTableFieldPathBuilder {
10791        #[allow(clippy::new_without_default)]
10792        pub fn new() -> Self {
10793            Self { path: Default::default() }
10794        }
10795        #[doc(hidden)]
10796        pub fn new_with_base(base: Vec<&'static str>) -> Self {
10797            Self { path: base }
10798        }
10799        pub fn finish(self) -> String {
10800            self.path.join(".")
10801        }
10802        pub fn id(mut self) -> String {
10803            self.path.push(MoveTable::ID_FIELD.name);
10804            self.finish()
10805        }
10806        pub fn size(mut self) -> String {
10807            self.path.push(MoveTable::SIZE_FIELD.name);
10808            self.finish()
10809        }
10810    }
10811    impl StakeSubsidy {
10812        pub const BALANCE_FIELD: &'static MessageField = &MessageField {
10813            name: "balance",
10814            json_name: "balance",
10815            number: 1i32,
10816            message_fields: None,
10817        };
10818        pub const DISTRIBUTION_COUNTER_FIELD: &'static MessageField = &MessageField {
10819            name: "distribution_counter",
10820            json_name: "distributionCounter",
10821            number: 2i32,
10822            message_fields: None,
10823        };
10824        pub const CURRENT_DISTRIBUTION_AMOUNT_FIELD: &'static MessageField = &MessageField {
10825            name: "current_distribution_amount",
10826            json_name: "currentDistributionAmount",
10827            number: 3i32,
10828            message_fields: None,
10829        };
10830        pub const STAKE_SUBSIDY_PERIOD_LENGTH_FIELD: &'static MessageField = &MessageField {
10831            name: "stake_subsidy_period_length",
10832            json_name: "stakeSubsidyPeriodLength",
10833            number: 4i32,
10834            message_fields: None,
10835        };
10836        pub const STAKE_SUBSIDY_DECREASE_RATE_FIELD: &'static MessageField = &MessageField {
10837            name: "stake_subsidy_decrease_rate",
10838            json_name: "stakeSubsidyDecreaseRate",
10839            number: 5i32,
10840            message_fields: None,
10841        };
10842        pub const EXTRA_FIELDS_FIELD: &'static MessageField = &MessageField {
10843            name: "extra_fields",
10844            json_name: "extraFields",
10845            number: 6i32,
10846            message_fields: Some(MoveTable::FIELDS),
10847        };
10848    }
10849    impl MessageFields for StakeSubsidy {
10850        const FIELDS: &'static [&'static MessageField] = &[
10851            Self::BALANCE_FIELD,
10852            Self::DISTRIBUTION_COUNTER_FIELD,
10853            Self::CURRENT_DISTRIBUTION_AMOUNT_FIELD,
10854            Self::STAKE_SUBSIDY_PERIOD_LENGTH_FIELD,
10855            Self::STAKE_SUBSIDY_DECREASE_RATE_FIELD,
10856            Self::EXTRA_FIELDS_FIELD,
10857        ];
10858    }
10859    impl StakeSubsidy {
10860        pub fn path_builder() -> StakeSubsidyFieldPathBuilder {
10861            StakeSubsidyFieldPathBuilder::new()
10862        }
10863    }
10864    pub struct StakeSubsidyFieldPathBuilder {
10865        path: Vec<&'static str>,
10866    }
10867    impl StakeSubsidyFieldPathBuilder {
10868        #[allow(clippy::new_without_default)]
10869        pub fn new() -> Self {
10870            Self { path: Default::default() }
10871        }
10872        #[doc(hidden)]
10873        pub fn new_with_base(base: Vec<&'static str>) -> Self {
10874            Self { path: base }
10875        }
10876        pub fn finish(self) -> String {
10877            self.path.join(".")
10878        }
10879        pub fn balance(mut self) -> String {
10880            self.path.push(StakeSubsidy::BALANCE_FIELD.name);
10881            self.finish()
10882        }
10883        pub fn distribution_counter(mut self) -> String {
10884            self.path.push(StakeSubsidy::DISTRIBUTION_COUNTER_FIELD.name);
10885            self.finish()
10886        }
10887        pub fn current_distribution_amount(mut self) -> String {
10888            self.path.push(StakeSubsidy::CURRENT_DISTRIBUTION_AMOUNT_FIELD.name);
10889            self.finish()
10890        }
10891        pub fn stake_subsidy_period_length(mut self) -> String {
10892            self.path.push(StakeSubsidy::STAKE_SUBSIDY_PERIOD_LENGTH_FIELD.name);
10893            self.finish()
10894        }
10895        pub fn stake_subsidy_decrease_rate(mut self) -> String {
10896            self.path.push(StakeSubsidy::STAKE_SUBSIDY_DECREASE_RATE_FIELD.name);
10897            self.finish()
10898        }
10899        pub fn extra_fields(mut self) -> MoveTableFieldPathBuilder {
10900            self.path.push(StakeSubsidy::EXTRA_FIELDS_FIELD.name);
10901            MoveTableFieldPathBuilder::new_with_base(self.path)
10902        }
10903    }
10904    impl StorageFund {
10905        pub const TOTAL_OBJECT_STORAGE_REBATES_FIELD: &'static MessageField = &MessageField {
10906            name: "total_object_storage_rebates",
10907            json_name: "totalObjectStorageRebates",
10908            number: 1i32,
10909            message_fields: None,
10910        };
10911        pub const NON_REFUNDABLE_BALANCE_FIELD: &'static MessageField = &MessageField {
10912            name: "non_refundable_balance",
10913            json_name: "nonRefundableBalance",
10914            number: 2i32,
10915            message_fields: None,
10916        };
10917    }
10918    impl MessageFields for StorageFund {
10919        const FIELDS: &'static [&'static MessageField] = &[
10920            Self::TOTAL_OBJECT_STORAGE_REBATES_FIELD,
10921            Self::NON_REFUNDABLE_BALANCE_FIELD,
10922        ];
10923    }
10924    impl StorageFund {
10925        pub fn path_builder() -> StorageFundFieldPathBuilder {
10926            StorageFundFieldPathBuilder::new()
10927        }
10928    }
10929    pub struct StorageFundFieldPathBuilder {
10930        path: Vec<&'static str>,
10931    }
10932    impl StorageFundFieldPathBuilder {
10933        #[allow(clippy::new_without_default)]
10934        pub fn new() -> Self {
10935            Self { path: Default::default() }
10936        }
10937        #[doc(hidden)]
10938        pub fn new_with_base(base: Vec<&'static str>) -> Self {
10939            Self { path: base }
10940        }
10941        pub fn finish(self) -> String {
10942            self.path.join(".")
10943        }
10944        pub fn total_object_storage_rebates(mut self) -> String {
10945            self.path.push(StorageFund::TOTAL_OBJECT_STORAGE_REBATES_FIELD.name);
10946            self.finish()
10947        }
10948        pub fn non_refundable_balance(mut self) -> String {
10949            self.path.push(StorageFund::NON_REFUNDABLE_BALANCE_FIELD.name);
10950            self.finish()
10951        }
10952    }
10953    impl ValidatorSet {
10954        pub const TOTAL_STAKE_FIELD: &'static MessageField = &MessageField {
10955            name: "total_stake",
10956            json_name: "totalStake",
10957            number: 1i32,
10958            message_fields: None,
10959        };
10960        pub const ACTIVE_VALIDATORS_FIELD: &'static MessageField = &MessageField {
10961            name: "active_validators",
10962            json_name: "activeValidators",
10963            number: 2i32,
10964            message_fields: Some(Validator::FIELDS),
10965        };
10966        pub const PENDING_ACTIVE_VALIDATORS_FIELD: &'static MessageField = &MessageField {
10967            name: "pending_active_validators",
10968            json_name: "pendingActiveValidators",
10969            number: 3i32,
10970            message_fields: Some(MoveTable::FIELDS),
10971        };
10972        pub const PENDING_REMOVALS_FIELD: &'static MessageField = &MessageField {
10973            name: "pending_removals",
10974            json_name: "pendingRemovals",
10975            number: 4i32,
10976            message_fields: None,
10977        };
10978        pub const STAKING_POOL_MAPPINGS_FIELD: &'static MessageField = &MessageField {
10979            name: "staking_pool_mappings",
10980            json_name: "stakingPoolMappings",
10981            number: 5i32,
10982            message_fields: Some(MoveTable::FIELDS),
10983        };
10984        pub const INACTIVE_VALIDATORS_FIELD: &'static MessageField = &MessageField {
10985            name: "inactive_validators",
10986            json_name: "inactiveValidators",
10987            number: 6i32,
10988            message_fields: Some(MoveTable::FIELDS),
10989        };
10990        pub const VALIDATOR_CANDIDATES_FIELD: &'static MessageField = &MessageField {
10991            name: "validator_candidates",
10992            json_name: "validatorCandidates",
10993            number: 7i32,
10994            message_fields: Some(MoveTable::FIELDS),
10995        };
10996        pub const AT_RISK_VALIDATORS_FIELD: &'static MessageField = &MessageField {
10997            name: "at_risk_validators",
10998            json_name: "atRiskValidators",
10999            number: 8i32,
11000            message_fields: None,
11001        };
11002        pub const EXTRA_FIELDS_FIELD: &'static MessageField = &MessageField {
11003            name: "extra_fields",
11004            json_name: "extraFields",
11005            number: 9i32,
11006            message_fields: Some(MoveTable::FIELDS),
11007        };
11008    }
11009    impl MessageFields for ValidatorSet {
11010        const FIELDS: &'static [&'static MessageField] = &[
11011            Self::TOTAL_STAKE_FIELD,
11012            Self::ACTIVE_VALIDATORS_FIELD,
11013            Self::PENDING_ACTIVE_VALIDATORS_FIELD,
11014            Self::PENDING_REMOVALS_FIELD,
11015            Self::STAKING_POOL_MAPPINGS_FIELD,
11016            Self::INACTIVE_VALIDATORS_FIELD,
11017            Self::VALIDATOR_CANDIDATES_FIELD,
11018            Self::AT_RISK_VALIDATORS_FIELD,
11019            Self::EXTRA_FIELDS_FIELD,
11020        ];
11021    }
11022    impl ValidatorSet {
11023        pub fn path_builder() -> ValidatorSetFieldPathBuilder {
11024            ValidatorSetFieldPathBuilder::new()
11025        }
11026    }
11027    pub struct ValidatorSetFieldPathBuilder {
11028        path: Vec<&'static str>,
11029    }
11030    impl ValidatorSetFieldPathBuilder {
11031        #[allow(clippy::new_without_default)]
11032        pub fn new() -> Self {
11033            Self { path: Default::default() }
11034        }
11035        #[doc(hidden)]
11036        pub fn new_with_base(base: Vec<&'static str>) -> Self {
11037            Self { path: base }
11038        }
11039        pub fn finish(self) -> String {
11040            self.path.join(".")
11041        }
11042        pub fn total_stake(mut self) -> String {
11043            self.path.push(ValidatorSet::TOTAL_STAKE_FIELD.name);
11044            self.finish()
11045        }
11046        pub fn active_validators(mut self) -> ValidatorFieldPathBuilder {
11047            self.path.push(ValidatorSet::ACTIVE_VALIDATORS_FIELD.name);
11048            ValidatorFieldPathBuilder::new_with_base(self.path)
11049        }
11050        pub fn pending_active_validators(mut self) -> MoveTableFieldPathBuilder {
11051            self.path.push(ValidatorSet::PENDING_ACTIVE_VALIDATORS_FIELD.name);
11052            MoveTableFieldPathBuilder::new_with_base(self.path)
11053        }
11054        pub fn pending_removals(mut self) -> String {
11055            self.path.push(ValidatorSet::PENDING_REMOVALS_FIELD.name);
11056            self.finish()
11057        }
11058        pub fn staking_pool_mappings(mut self) -> MoveTableFieldPathBuilder {
11059            self.path.push(ValidatorSet::STAKING_POOL_MAPPINGS_FIELD.name);
11060            MoveTableFieldPathBuilder::new_with_base(self.path)
11061        }
11062        pub fn inactive_validators(mut self) -> MoveTableFieldPathBuilder {
11063            self.path.push(ValidatorSet::INACTIVE_VALIDATORS_FIELD.name);
11064            MoveTableFieldPathBuilder::new_with_base(self.path)
11065        }
11066        pub fn validator_candidates(mut self) -> MoveTableFieldPathBuilder {
11067            self.path.push(ValidatorSet::VALIDATOR_CANDIDATES_FIELD.name);
11068            MoveTableFieldPathBuilder::new_with_base(self.path)
11069        }
11070        pub fn at_risk_validators(mut self) -> String {
11071            self.path.push(ValidatorSet::AT_RISK_VALIDATORS_FIELD.name);
11072            self.finish()
11073        }
11074        pub fn extra_fields(mut self) -> MoveTableFieldPathBuilder {
11075            self.path.push(ValidatorSet::EXTRA_FIELDS_FIELD.name);
11076            MoveTableFieldPathBuilder::new_with_base(self.path)
11077        }
11078    }
11079    impl Validator {
11080        pub const NAME_FIELD: &'static MessageField = &MessageField {
11081            name: "name",
11082            json_name: "name",
11083            number: 1i32,
11084            message_fields: None,
11085        };
11086        pub const ADDRESS_FIELD: &'static MessageField = &MessageField {
11087            name: "address",
11088            json_name: "address",
11089            number: 2i32,
11090            message_fields: None,
11091        };
11092        pub const DESCRIPTION_FIELD: &'static MessageField = &MessageField {
11093            name: "description",
11094            json_name: "description",
11095            number: 3i32,
11096            message_fields: None,
11097        };
11098        pub const IMAGE_URL_FIELD: &'static MessageField = &MessageField {
11099            name: "image_url",
11100            json_name: "imageUrl",
11101            number: 4i32,
11102            message_fields: None,
11103        };
11104        pub const PROJECT_URL_FIELD: &'static MessageField = &MessageField {
11105            name: "project_url",
11106            json_name: "projectUrl",
11107            number: 5i32,
11108            message_fields: None,
11109        };
11110        pub const PROTOCOL_PUBLIC_KEY_FIELD: &'static MessageField = &MessageField {
11111            name: "protocol_public_key",
11112            json_name: "protocolPublicKey",
11113            number: 7i32,
11114            message_fields: None,
11115        };
11116        pub const PROOF_OF_POSSESSION_FIELD: &'static MessageField = &MessageField {
11117            name: "proof_of_possession",
11118            json_name: "proofOfPossession",
11119            number: 8i32,
11120            message_fields: None,
11121        };
11122        pub const NETWORK_PUBLIC_KEY_FIELD: &'static MessageField = &MessageField {
11123            name: "network_public_key",
11124            json_name: "networkPublicKey",
11125            number: 10i32,
11126            message_fields: None,
11127        };
11128        pub const WORKER_PUBLIC_KEY_FIELD: &'static MessageField = &MessageField {
11129            name: "worker_public_key",
11130            json_name: "workerPublicKey",
11131            number: 12i32,
11132            message_fields: None,
11133        };
11134        pub const NETWORK_ADDRESS_FIELD: &'static MessageField = &MessageField {
11135            name: "network_address",
11136            json_name: "networkAddress",
11137            number: 13i32,
11138            message_fields: None,
11139        };
11140        pub const P2P_ADDRESS_FIELD: &'static MessageField = &MessageField {
11141            name: "p2p_address",
11142            json_name: "p2pAddress",
11143            number: 14i32,
11144            message_fields: None,
11145        };
11146        pub const PRIMARY_ADDRESS_FIELD: &'static MessageField = &MessageField {
11147            name: "primary_address",
11148            json_name: "primaryAddress",
11149            number: 15i32,
11150            message_fields: None,
11151        };
11152        pub const WORKER_ADDRESS_FIELD: &'static MessageField = &MessageField {
11153            name: "worker_address",
11154            json_name: "workerAddress",
11155            number: 16i32,
11156            message_fields: None,
11157        };
11158        pub const NEXT_EPOCH_PROTOCOL_PUBLIC_KEY_FIELD: &'static MessageField = &MessageField {
11159            name: "next_epoch_protocol_public_key",
11160            json_name: "nextEpochProtocolPublicKey",
11161            number: 18i32,
11162            message_fields: None,
11163        };
11164        pub const NEXT_EPOCH_PROOF_OF_POSSESSION_FIELD: &'static MessageField = &MessageField {
11165            name: "next_epoch_proof_of_possession",
11166            json_name: "nextEpochProofOfPossession",
11167            number: 19i32,
11168            message_fields: None,
11169        };
11170        pub const NEXT_EPOCH_NETWORK_PUBLIC_KEY_FIELD: &'static MessageField = &MessageField {
11171            name: "next_epoch_network_public_key",
11172            json_name: "nextEpochNetworkPublicKey",
11173            number: 21i32,
11174            message_fields: None,
11175        };
11176        pub const NEXT_EPOCH_WORKER_PUBLIC_KEY_FIELD: &'static MessageField = &MessageField {
11177            name: "next_epoch_worker_public_key",
11178            json_name: "nextEpochWorkerPublicKey",
11179            number: 23i32,
11180            message_fields: None,
11181        };
11182        pub const NEXT_EPOCH_NETWORK_ADDRESS_FIELD: &'static MessageField = &MessageField {
11183            name: "next_epoch_network_address",
11184            json_name: "nextEpochNetworkAddress",
11185            number: 24i32,
11186            message_fields: None,
11187        };
11188        pub const NEXT_EPOCH_P2P_ADDRESS_FIELD: &'static MessageField = &MessageField {
11189            name: "next_epoch_p2p_address",
11190            json_name: "nextEpochP2pAddress",
11191            number: 25i32,
11192            message_fields: None,
11193        };
11194        pub const NEXT_EPOCH_PRIMARY_ADDRESS_FIELD: &'static MessageField = &MessageField {
11195            name: "next_epoch_primary_address",
11196            json_name: "nextEpochPrimaryAddress",
11197            number: 26i32,
11198            message_fields: None,
11199        };
11200        pub const NEXT_EPOCH_WORKER_ADDRESS_FIELD: &'static MessageField = &MessageField {
11201            name: "next_epoch_worker_address",
11202            json_name: "nextEpochWorkerAddress",
11203            number: 27i32,
11204            message_fields: None,
11205        };
11206        pub const METADATA_EXTRA_FIELDS_FIELD: &'static MessageField = &MessageField {
11207            name: "metadata_extra_fields",
11208            json_name: "metadataExtraFields",
11209            number: 28i32,
11210            message_fields: Some(MoveTable::FIELDS),
11211        };
11212        pub const VOTING_POWER_FIELD: &'static MessageField = &MessageField {
11213            name: "voting_power",
11214            json_name: "votingPower",
11215            number: 29i32,
11216            message_fields: None,
11217        };
11218        pub const OPERATION_CAP_ID_FIELD: &'static MessageField = &MessageField {
11219            name: "operation_cap_id",
11220            json_name: "operationCapId",
11221            number: 30i32,
11222            message_fields: None,
11223        };
11224        pub const GAS_PRICE_FIELD: &'static MessageField = &MessageField {
11225            name: "gas_price",
11226            json_name: "gasPrice",
11227            number: 31i32,
11228            message_fields: None,
11229        };
11230        pub const STAKING_POOL_FIELD: &'static MessageField = &MessageField {
11231            name: "staking_pool",
11232            json_name: "stakingPool",
11233            number: 32i32,
11234            message_fields: Some(StakingPool::FIELDS),
11235        };
11236        pub const COMMISSION_RATE_FIELD: &'static MessageField = &MessageField {
11237            name: "commission_rate",
11238            json_name: "commissionRate",
11239            number: 33i32,
11240            message_fields: None,
11241        };
11242        pub const NEXT_EPOCH_STAKE_FIELD: &'static MessageField = &MessageField {
11243            name: "next_epoch_stake",
11244            json_name: "nextEpochStake",
11245            number: 34i32,
11246            message_fields: None,
11247        };
11248        pub const NEXT_EPOCH_GAS_PRICE_FIELD: &'static MessageField = &MessageField {
11249            name: "next_epoch_gas_price",
11250            json_name: "nextEpochGasPrice",
11251            number: 35i32,
11252            message_fields: None,
11253        };
11254        pub const NEXT_EPOCH_COMMISSION_RATE_FIELD: &'static MessageField = &MessageField {
11255            name: "next_epoch_commission_rate",
11256            json_name: "nextEpochCommissionRate",
11257            number: 36i32,
11258            message_fields: None,
11259        };
11260        pub const EXTRA_FIELDS_FIELD: &'static MessageField = &MessageField {
11261            name: "extra_fields",
11262            json_name: "extraFields",
11263            number: 37i32,
11264            message_fields: Some(MoveTable::FIELDS),
11265        };
11266    }
11267    impl MessageFields for Validator {
11268        const FIELDS: &'static [&'static MessageField] = &[
11269            Self::NAME_FIELD,
11270            Self::ADDRESS_FIELD,
11271            Self::DESCRIPTION_FIELD,
11272            Self::IMAGE_URL_FIELD,
11273            Self::PROJECT_URL_FIELD,
11274            Self::PROTOCOL_PUBLIC_KEY_FIELD,
11275            Self::PROOF_OF_POSSESSION_FIELD,
11276            Self::NETWORK_PUBLIC_KEY_FIELD,
11277            Self::WORKER_PUBLIC_KEY_FIELD,
11278            Self::NETWORK_ADDRESS_FIELD,
11279            Self::P2P_ADDRESS_FIELD,
11280            Self::PRIMARY_ADDRESS_FIELD,
11281            Self::WORKER_ADDRESS_FIELD,
11282            Self::NEXT_EPOCH_PROTOCOL_PUBLIC_KEY_FIELD,
11283            Self::NEXT_EPOCH_PROOF_OF_POSSESSION_FIELD,
11284            Self::NEXT_EPOCH_NETWORK_PUBLIC_KEY_FIELD,
11285            Self::NEXT_EPOCH_WORKER_PUBLIC_KEY_FIELD,
11286            Self::NEXT_EPOCH_NETWORK_ADDRESS_FIELD,
11287            Self::NEXT_EPOCH_P2P_ADDRESS_FIELD,
11288            Self::NEXT_EPOCH_PRIMARY_ADDRESS_FIELD,
11289            Self::NEXT_EPOCH_WORKER_ADDRESS_FIELD,
11290            Self::METADATA_EXTRA_FIELDS_FIELD,
11291            Self::VOTING_POWER_FIELD,
11292            Self::OPERATION_CAP_ID_FIELD,
11293            Self::GAS_PRICE_FIELD,
11294            Self::STAKING_POOL_FIELD,
11295            Self::COMMISSION_RATE_FIELD,
11296            Self::NEXT_EPOCH_STAKE_FIELD,
11297            Self::NEXT_EPOCH_GAS_PRICE_FIELD,
11298            Self::NEXT_EPOCH_COMMISSION_RATE_FIELD,
11299            Self::EXTRA_FIELDS_FIELD,
11300        ];
11301    }
11302    impl Validator {
11303        pub fn path_builder() -> ValidatorFieldPathBuilder {
11304            ValidatorFieldPathBuilder::new()
11305        }
11306    }
11307    pub struct ValidatorFieldPathBuilder {
11308        path: Vec<&'static str>,
11309    }
11310    impl ValidatorFieldPathBuilder {
11311        #[allow(clippy::new_without_default)]
11312        pub fn new() -> Self {
11313            Self { path: Default::default() }
11314        }
11315        #[doc(hidden)]
11316        pub fn new_with_base(base: Vec<&'static str>) -> Self {
11317            Self { path: base }
11318        }
11319        pub fn finish(self) -> String {
11320            self.path.join(".")
11321        }
11322        pub fn name(mut self) -> String {
11323            self.path.push(Validator::NAME_FIELD.name);
11324            self.finish()
11325        }
11326        pub fn address(mut self) -> String {
11327            self.path.push(Validator::ADDRESS_FIELD.name);
11328            self.finish()
11329        }
11330        pub fn description(mut self) -> String {
11331            self.path.push(Validator::DESCRIPTION_FIELD.name);
11332            self.finish()
11333        }
11334        pub fn image_url(mut self) -> String {
11335            self.path.push(Validator::IMAGE_URL_FIELD.name);
11336            self.finish()
11337        }
11338        pub fn project_url(mut self) -> String {
11339            self.path.push(Validator::PROJECT_URL_FIELD.name);
11340            self.finish()
11341        }
11342        pub fn protocol_public_key(mut self) -> String {
11343            self.path.push(Validator::PROTOCOL_PUBLIC_KEY_FIELD.name);
11344            self.finish()
11345        }
11346        pub fn proof_of_possession(mut self) -> String {
11347            self.path.push(Validator::PROOF_OF_POSSESSION_FIELD.name);
11348            self.finish()
11349        }
11350        pub fn network_public_key(mut self) -> String {
11351            self.path.push(Validator::NETWORK_PUBLIC_KEY_FIELD.name);
11352            self.finish()
11353        }
11354        pub fn worker_public_key(mut self) -> String {
11355            self.path.push(Validator::WORKER_PUBLIC_KEY_FIELD.name);
11356            self.finish()
11357        }
11358        pub fn network_address(mut self) -> String {
11359            self.path.push(Validator::NETWORK_ADDRESS_FIELD.name);
11360            self.finish()
11361        }
11362        pub fn p2p_address(mut self) -> String {
11363            self.path.push(Validator::P2P_ADDRESS_FIELD.name);
11364            self.finish()
11365        }
11366        pub fn primary_address(mut self) -> String {
11367            self.path.push(Validator::PRIMARY_ADDRESS_FIELD.name);
11368            self.finish()
11369        }
11370        pub fn worker_address(mut self) -> String {
11371            self.path.push(Validator::WORKER_ADDRESS_FIELD.name);
11372            self.finish()
11373        }
11374        pub fn next_epoch_protocol_public_key(mut self) -> String {
11375            self.path.push(Validator::NEXT_EPOCH_PROTOCOL_PUBLIC_KEY_FIELD.name);
11376            self.finish()
11377        }
11378        pub fn next_epoch_proof_of_possession(mut self) -> String {
11379            self.path.push(Validator::NEXT_EPOCH_PROOF_OF_POSSESSION_FIELD.name);
11380            self.finish()
11381        }
11382        pub fn next_epoch_network_public_key(mut self) -> String {
11383            self.path.push(Validator::NEXT_EPOCH_NETWORK_PUBLIC_KEY_FIELD.name);
11384            self.finish()
11385        }
11386        pub fn next_epoch_worker_public_key(mut self) -> String {
11387            self.path.push(Validator::NEXT_EPOCH_WORKER_PUBLIC_KEY_FIELD.name);
11388            self.finish()
11389        }
11390        pub fn next_epoch_network_address(mut self) -> String {
11391            self.path.push(Validator::NEXT_EPOCH_NETWORK_ADDRESS_FIELD.name);
11392            self.finish()
11393        }
11394        pub fn next_epoch_p2p_address(mut self) -> String {
11395            self.path.push(Validator::NEXT_EPOCH_P2P_ADDRESS_FIELD.name);
11396            self.finish()
11397        }
11398        pub fn next_epoch_primary_address(mut self) -> String {
11399            self.path.push(Validator::NEXT_EPOCH_PRIMARY_ADDRESS_FIELD.name);
11400            self.finish()
11401        }
11402        pub fn next_epoch_worker_address(mut self) -> String {
11403            self.path.push(Validator::NEXT_EPOCH_WORKER_ADDRESS_FIELD.name);
11404            self.finish()
11405        }
11406        pub fn metadata_extra_fields(mut self) -> MoveTableFieldPathBuilder {
11407            self.path.push(Validator::METADATA_EXTRA_FIELDS_FIELD.name);
11408            MoveTableFieldPathBuilder::new_with_base(self.path)
11409        }
11410        pub fn voting_power(mut self) -> String {
11411            self.path.push(Validator::VOTING_POWER_FIELD.name);
11412            self.finish()
11413        }
11414        pub fn operation_cap_id(mut self) -> String {
11415            self.path.push(Validator::OPERATION_CAP_ID_FIELD.name);
11416            self.finish()
11417        }
11418        pub fn gas_price(mut self) -> String {
11419            self.path.push(Validator::GAS_PRICE_FIELD.name);
11420            self.finish()
11421        }
11422        pub fn staking_pool(mut self) -> StakingPoolFieldPathBuilder {
11423            self.path.push(Validator::STAKING_POOL_FIELD.name);
11424            StakingPoolFieldPathBuilder::new_with_base(self.path)
11425        }
11426        pub fn commission_rate(mut self) -> String {
11427            self.path.push(Validator::COMMISSION_RATE_FIELD.name);
11428            self.finish()
11429        }
11430        pub fn next_epoch_stake(mut self) -> String {
11431            self.path.push(Validator::NEXT_EPOCH_STAKE_FIELD.name);
11432            self.finish()
11433        }
11434        pub fn next_epoch_gas_price(mut self) -> String {
11435            self.path.push(Validator::NEXT_EPOCH_GAS_PRICE_FIELD.name);
11436            self.finish()
11437        }
11438        pub fn next_epoch_commission_rate(mut self) -> String {
11439            self.path.push(Validator::NEXT_EPOCH_COMMISSION_RATE_FIELD.name);
11440            self.finish()
11441        }
11442        pub fn extra_fields(mut self) -> MoveTableFieldPathBuilder {
11443            self.path.push(Validator::EXTRA_FIELDS_FIELD.name);
11444            MoveTableFieldPathBuilder::new_with_base(self.path)
11445        }
11446    }
11447    impl StakingPool {
11448        pub const ID_FIELD: &'static MessageField = &MessageField {
11449            name: "id",
11450            json_name: "id",
11451            number: 1i32,
11452            message_fields: None,
11453        };
11454        pub const ACTIVATION_EPOCH_FIELD: &'static MessageField = &MessageField {
11455            name: "activation_epoch",
11456            json_name: "activationEpoch",
11457            number: 2i32,
11458            message_fields: None,
11459        };
11460        pub const DEACTIVATION_EPOCH_FIELD: &'static MessageField = &MessageField {
11461            name: "deactivation_epoch",
11462            json_name: "deactivationEpoch",
11463            number: 3i32,
11464            message_fields: None,
11465        };
11466        pub const SUI_BALANCE_FIELD: &'static MessageField = &MessageField {
11467            name: "sui_balance",
11468            json_name: "suiBalance",
11469            number: 4i32,
11470            message_fields: None,
11471        };
11472        pub const REWARDS_POOL_FIELD: &'static MessageField = &MessageField {
11473            name: "rewards_pool",
11474            json_name: "rewardsPool",
11475            number: 5i32,
11476            message_fields: None,
11477        };
11478        pub const POOL_TOKEN_BALANCE_FIELD: &'static MessageField = &MessageField {
11479            name: "pool_token_balance",
11480            json_name: "poolTokenBalance",
11481            number: 6i32,
11482            message_fields: None,
11483        };
11484        pub const EXCHANGE_RATES_FIELD: &'static MessageField = &MessageField {
11485            name: "exchange_rates",
11486            json_name: "exchangeRates",
11487            number: 7i32,
11488            message_fields: Some(MoveTable::FIELDS),
11489        };
11490        pub const PENDING_STAKE_FIELD: &'static MessageField = &MessageField {
11491            name: "pending_stake",
11492            json_name: "pendingStake",
11493            number: 8i32,
11494            message_fields: None,
11495        };
11496        pub const PENDING_TOTAL_SUI_WITHDRAW_FIELD: &'static MessageField = &MessageField {
11497            name: "pending_total_sui_withdraw",
11498            json_name: "pendingTotalSuiWithdraw",
11499            number: 9i32,
11500            message_fields: None,
11501        };
11502        pub const PENDING_POOL_TOKEN_WITHDRAW_FIELD: &'static MessageField = &MessageField {
11503            name: "pending_pool_token_withdraw",
11504            json_name: "pendingPoolTokenWithdraw",
11505            number: 10i32,
11506            message_fields: None,
11507        };
11508        pub const EXTRA_FIELDS_FIELD: &'static MessageField = &MessageField {
11509            name: "extra_fields",
11510            json_name: "extraFields",
11511            number: 11i32,
11512            message_fields: Some(MoveTable::FIELDS),
11513        };
11514    }
11515    impl MessageFields for StakingPool {
11516        const FIELDS: &'static [&'static MessageField] = &[
11517            Self::ID_FIELD,
11518            Self::ACTIVATION_EPOCH_FIELD,
11519            Self::DEACTIVATION_EPOCH_FIELD,
11520            Self::SUI_BALANCE_FIELD,
11521            Self::REWARDS_POOL_FIELD,
11522            Self::POOL_TOKEN_BALANCE_FIELD,
11523            Self::EXCHANGE_RATES_FIELD,
11524            Self::PENDING_STAKE_FIELD,
11525            Self::PENDING_TOTAL_SUI_WITHDRAW_FIELD,
11526            Self::PENDING_POOL_TOKEN_WITHDRAW_FIELD,
11527            Self::EXTRA_FIELDS_FIELD,
11528        ];
11529    }
11530    impl StakingPool {
11531        pub fn path_builder() -> StakingPoolFieldPathBuilder {
11532            StakingPoolFieldPathBuilder::new()
11533        }
11534    }
11535    pub struct StakingPoolFieldPathBuilder {
11536        path: Vec<&'static str>,
11537    }
11538    impl StakingPoolFieldPathBuilder {
11539        #[allow(clippy::new_without_default)]
11540        pub fn new() -> Self {
11541            Self { path: Default::default() }
11542        }
11543        #[doc(hidden)]
11544        pub fn new_with_base(base: Vec<&'static str>) -> Self {
11545            Self { path: base }
11546        }
11547        pub fn finish(self) -> String {
11548            self.path.join(".")
11549        }
11550        pub fn id(mut self) -> String {
11551            self.path.push(StakingPool::ID_FIELD.name);
11552            self.finish()
11553        }
11554        pub fn activation_epoch(mut self) -> String {
11555            self.path.push(StakingPool::ACTIVATION_EPOCH_FIELD.name);
11556            self.finish()
11557        }
11558        pub fn deactivation_epoch(mut self) -> String {
11559            self.path.push(StakingPool::DEACTIVATION_EPOCH_FIELD.name);
11560            self.finish()
11561        }
11562        pub fn sui_balance(mut self) -> String {
11563            self.path.push(StakingPool::SUI_BALANCE_FIELD.name);
11564            self.finish()
11565        }
11566        pub fn rewards_pool(mut self) -> String {
11567            self.path.push(StakingPool::REWARDS_POOL_FIELD.name);
11568            self.finish()
11569        }
11570        pub fn pool_token_balance(mut self) -> String {
11571            self.path.push(StakingPool::POOL_TOKEN_BALANCE_FIELD.name);
11572            self.finish()
11573        }
11574        pub fn exchange_rates(mut self) -> MoveTableFieldPathBuilder {
11575            self.path.push(StakingPool::EXCHANGE_RATES_FIELD.name);
11576            MoveTableFieldPathBuilder::new_with_base(self.path)
11577        }
11578        pub fn pending_stake(mut self) -> String {
11579            self.path.push(StakingPool::PENDING_STAKE_FIELD.name);
11580            self.finish()
11581        }
11582        pub fn pending_total_sui_withdraw(mut self) -> String {
11583            self.path.push(StakingPool::PENDING_TOTAL_SUI_WITHDRAW_FIELD.name);
11584            self.finish()
11585        }
11586        pub fn pending_pool_token_withdraw(mut self) -> String {
11587            self.path.push(StakingPool::PENDING_POOL_TOKEN_WITHDRAW_FIELD.name);
11588            self.finish()
11589        }
11590        pub fn extra_fields(mut self) -> MoveTableFieldPathBuilder {
11591            self.path.push(StakingPool::EXTRA_FIELDS_FIELD.name);
11592            MoveTableFieldPathBuilder::new_with_base(self.path)
11593        }
11594    }
11595    impl Transaction {
11596        pub const BCS_FIELD: &'static MessageField = &MessageField {
11597            name: "bcs",
11598            json_name: "bcs",
11599            number: 1i32,
11600            message_fields: Some(Bcs::FIELDS),
11601        };
11602        pub const DIGEST_FIELD: &'static MessageField = &MessageField {
11603            name: "digest",
11604            json_name: "digest",
11605            number: 2i32,
11606            message_fields: None,
11607        };
11608        pub const VERSION_FIELD: &'static MessageField = &MessageField {
11609            name: "version",
11610            json_name: "version",
11611            number: 3i32,
11612            message_fields: None,
11613        };
11614        pub const KIND_FIELD: &'static MessageField = &MessageField {
11615            name: "kind",
11616            json_name: "kind",
11617            number: 4i32,
11618            message_fields: Some(TransactionKind::FIELDS),
11619        };
11620        pub const SENDER_FIELD: &'static MessageField = &MessageField {
11621            name: "sender",
11622            json_name: "sender",
11623            number: 5i32,
11624            message_fields: None,
11625        };
11626        pub const GAS_PAYMENT_FIELD: &'static MessageField = &MessageField {
11627            name: "gas_payment",
11628            json_name: "gasPayment",
11629            number: 6i32,
11630            message_fields: Some(GasPayment::FIELDS),
11631        };
11632        pub const EXPIRATION_FIELD: &'static MessageField = &MessageField {
11633            name: "expiration",
11634            json_name: "expiration",
11635            number: 7i32,
11636            message_fields: Some(TransactionExpiration::FIELDS),
11637        };
11638    }
11639    impl MessageFields for Transaction {
11640        const FIELDS: &'static [&'static MessageField] = &[
11641            Self::BCS_FIELD,
11642            Self::DIGEST_FIELD,
11643            Self::VERSION_FIELD,
11644            Self::KIND_FIELD,
11645            Self::SENDER_FIELD,
11646            Self::GAS_PAYMENT_FIELD,
11647            Self::EXPIRATION_FIELD,
11648        ];
11649    }
11650    impl Transaction {
11651        pub fn path_builder() -> TransactionFieldPathBuilder {
11652            TransactionFieldPathBuilder::new()
11653        }
11654    }
11655    pub struct TransactionFieldPathBuilder {
11656        path: Vec<&'static str>,
11657    }
11658    impl TransactionFieldPathBuilder {
11659        #[allow(clippy::new_without_default)]
11660        pub fn new() -> Self {
11661            Self { path: Default::default() }
11662        }
11663        #[doc(hidden)]
11664        pub fn new_with_base(base: Vec<&'static str>) -> Self {
11665            Self { path: base }
11666        }
11667        pub fn finish(self) -> String {
11668            self.path.join(".")
11669        }
11670        pub fn bcs(mut self) -> BcsFieldPathBuilder {
11671            self.path.push(Transaction::BCS_FIELD.name);
11672            BcsFieldPathBuilder::new_with_base(self.path)
11673        }
11674        pub fn digest(mut self) -> String {
11675            self.path.push(Transaction::DIGEST_FIELD.name);
11676            self.finish()
11677        }
11678        pub fn version(mut self) -> String {
11679            self.path.push(Transaction::VERSION_FIELD.name);
11680            self.finish()
11681        }
11682        pub fn kind(mut self) -> TransactionKindFieldPathBuilder {
11683            self.path.push(Transaction::KIND_FIELD.name);
11684            TransactionKindFieldPathBuilder::new_with_base(self.path)
11685        }
11686        pub fn sender(mut self) -> String {
11687            self.path.push(Transaction::SENDER_FIELD.name);
11688            self.finish()
11689        }
11690        pub fn gas_payment(mut self) -> GasPaymentFieldPathBuilder {
11691            self.path.push(Transaction::GAS_PAYMENT_FIELD.name);
11692            GasPaymentFieldPathBuilder::new_with_base(self.path)
11693        }
11694        pub fn expiration(mut self) -> TransactionExpirationFieldPathBuilder {
11695            self.path.push(Transaction::EXPIRATION_FIELD.name);
11696            TransactionExpirationFieldPathBuilder::new_with_base(self.path)
11697        }
11698    }
11699    impl GasPayment {
11700        pub const OBJECTS_FIELD: &'static MessageField = &MessageField {
11701            name: "objects",
11702            json_name: "objects",
11703            number: 1i32,
11704            message_fields: Some(ObjectReference::FIELDS),
11705        };
11706        pub const OWNER_FIELD: &'static MessageField = &MessageField {
11707            name: "owner",
11708            json_name: "owner",
11709            number: 2i32,
11710            message_fields: None,
11711        };
11712        pub const PRICE_FIELD: &'static MessageField = &MessageField {
11713            name: "price",
11714            json_name: "price",
11715            number: 3i32,
11716            message_fields: None,
11717        };
11718        pub const BUDGET_FIELD: &'static MessageField = &MessageField {
11719            name: "budget",
11720            json_name: "budget",
11721            number: 4i32,
11722            message_fields: None,
11723        };
11724    }
11725    impl MessageFields for GasPayment {
11726        const FIELDS: &'static [&'static MessageField] = &[
11727            Self::OBJECTS_FIELD,
11728            Self::OWNER_FIELD,
11729            Self::PRICE_FIELD,
11730            Self::BUDGET_FIELD,
11731        ];
11732    }
11733    impl GasPayment {
11734        pub fn path_builder() -> GasPaymentFieldPathBuilder {
11735            GasPaymentFieldPathBuilder::new()
11736        }
11737    }
11738    pub struct GasPaymentFieldPathBuilder {
11739        path: Vec<&'static str>,
11740    }
11741    impl GasPaymentFieldPathBuilder {
11742        #[allow(clippy::new_without_default)]
11743        pub fn new() -> Self {
11744            Self { path: Default::default() }
11745        }
11746        #[doc(hidden)]
11747        pub fn new_with_base(base: Vec<&'static str>) -> Self {
11748            Self { path: base }
11749        }
11750        pub fn finish(self) -> String {
11751            self.path.join(".")
11752        }
11753        pub fn objects(mut self) -> ObjectReferenceFieldPathBuilder {
11754            self.path.push(GasPayment::OBJECTS_FIELD.name);
11755            ObjectReferenceFieldPathBuilder::new_with_base(self.path)
11756        }
11757        pub fn owner(mut self) -> String {
11758            self.path.push(GasPayment::OWNER_FIELD.name);
11759            self.finish()
11760        }
11761        pub fn price(mut self) -> String {
11762            self.path.push(GasPayment::PRICE_FIELD.name);
11763            self.finish()
11764        }
11765        pub fn budget(mut self) -> String {
11766            self.path.push(GasPayment::BUDGET_FIELD.name);
11767            self.finish()
11768        }
11769    }
11770    impl TransactionExpiration {
11771        pub const KIND_FIELD: &'static MessageField = &MessageField {
11772            name: "kind",
11773            json_name: "kind",
11774            number: 1i32,
11775            message_fields: None,
11776        };
11777        pub const EPOCH_FIELD: &'static MessageField = &MessageField {
11778            name: "epoch",
11779            json_name: "epoch",
11780            number: 2i32,
11781            message_fields: None,
11782        };
11783        pub const MIN_EPOCH_FIELD: &'static MessageField = &MessageField {
11784            name: "min_epoch",
11785            json_name: "minEpoch",
11786            number: 3i32,
11787            message_fields: None,
11788        };
11789        pub const MIN_TIMESTAMP_FIELD: &'static MessageField = &MessageField {
11790            name: "min_timestamp",
11791            json_name: "minTimestamp",
11792            number: 4i32,
11793            message_fields: None,
11794        };
11795        pub const MAX_TIMESTAMP_FIELD: &'static MessageField = &MessageField {
11796            name: "max_timestamp",
11797            json_name: "maxTimestamp",
11798            number: 5i32,
11799            message_fields: None,
11800        };
11801        pub const CHAIN_FIELD: &'static MessageField = &MessageField {
11802            name: "chain",
11803            json_name: "chain",
11804            number: 6i32,
11805            message_fields: None,
11806        };
11807        pub const NONCE_FIELD: &'static MessageField = &MessageField {
11808            name: "nonce",
11809            json_name: "nonce",
11810            number: 7i32,
11811            message_fields: None,
11812        };
11813        pub const ALLOWED_PROPOSERS_FIELD: &'static MessageField = &MessageField {
11814            name: "allowed_proposers",
11815            json_name: "allowedProposers",
11816            number: 8i32,
11817            message_fields: Some(AllowedProposers::FIELDS),
11818        };
11819    }
11820    impl MessageFields for TransactionExpiration {
11821        const FIELDS: &'static [&'static MessageField] = &[
11822            Self::KIND_FIELD,
11823            Self::EPOCH_FIELD,
11824            Self::MIN_EPOCH_FIELD,
11825            Self::MIN_TIMESTAMP_FIELD,
11826            Self::MAX_TIMESTAMP_FIELD,
11827            Self::CHAIN_FIELD,
11828            Self::NONCE_FIELD,
11829            Self::ALLOWED_PROPOSERS_FIELD,
11830        ];
11831    }
11832    impl TransactionExpiration {
11833        pub fn path_builder() -> TransactionExpirationFieldPathBuilder {
11834            TransactionExpirationFieldPathBuilder::new()
11835        }
11836    }
11837    pub struct TransactionExpirationFieldPathBuilder {
11838        path: Vec<&'static str>,
11839    }
11840    impl TransactionExpirationFieldPathBuilder {
11841        #[allow(clippy::new_without_default)]
11842        pub fn new() -> Self {
11843            Self { path: Default::default() }
11844        }
11845        #[doc(hidden)]
11846        pub fn new_with_base(base: Vec<&'static str>) -> Self {
11847            Self { path: base }
11848        }
11849        pub fn finish(self) -> String {
11850            self.path.join(".")
11851        }
11852        pub fn kind(mut self) -> String {
11853            self.path.push(TransactionExpiration::KIND_FIELD.name);
11854            self.finish()
11855        }
11856        pub fn epoch(mut self) -> String {
11857            self.path.push(TransactionExpiration::EPOCH_FIELD.name);
11858            self.finish()
11859        }
11860        pub fn min_epoch(mut self) -> String {
11861            self.path.push(TransactionExpiration::MIN_EPOCH_FIELD.name);
11862            self.finish()
11863        }
11864        pub fn min_timestamp(mut self) -> String {
11865            self.path.push(TransactionExpiration::MIN_TIMESTAMP_FIELD.name);
11866            self.finish()
11867        }
11868        pub fn max_timestamp(mut self) -> String {
11869            self.path.push(TransactionExpiration::MAX_TIMESTAMP_FIELD.name);
11870            self.finish()
11871        }
11872        pub fn chain(mut self) -> String {
11873            self.path.push(TransactionExpiration::CHAIN_FIELD.name);
11874            self.finish()
11875        }
11876        pub fn nonce(mut self) -> String {
11877            self.path.push(TransactionExpiration::NONCE_FIELD.name);
11878            self.finish()
11879        }
11880        pub fn allowed_proposers(mut self) -> AllowedProposersFieldPathBuilder {
11881            self.path.push(TransactionExpiration::ALLOWED_PROPOSERS_FIELD.name);
11882            AllowedProposersFieldPathBuilder::new_with_base(self.path)
11883        }
11884    }
11885    impl AllowedProposers {
11886        pub const EPOCH_FIELD: &'static MessageField = &MessageField {
11887            name: "epoch",
11888            json_name: "epoch",
11889            number: 1i32,
11890            message_fields: None,
11891        };
11892        pub const PROPOSERS_FIELD: &'static MessageField = &MessageField {
11893            name: "proposers",
11894            json_name: "proposers",
11895            number: 2i32,
11896            message_fields: None,
11897        };
11898    }
11899    impl MessageFields for AllowedProposers {
11900        const FIELDS: &'static [&'static MessageField] = &[
11901            Self::EPOCH_FIELD,
11902            Self::PROPOSERS_FIELD,
11903        ];
11904    }
11905    impl AllowedProposers {
11906        pub fn path_builder() -> AllowedProposersFieldPathBuilder {
11907            AllowedProposersFieldPathBuilder::new()
11908        }
11909    }
11910    pub struct AllowedProposersFieldPathBuilder {
11911        path: Vec<&'static str>,
11912    }
11913    impl AllowedProposersFieldPathBuilder {
11914        #[allow(clippy::new_without_default)]
11915        pub fn new() -> Self {
11916            Self { path: Default::default() }
11917        }
11918        #[doc(hidden)]
11919        pub fn new_with_base(base: Vec<&'static str>) -> Self {
11920            Self { path: base }
11921        }
11922        pub fn finish(self) -> String {
11923            self.path.join(".")
11924        }
11925        pub fn epoch(mut self) -> String {
11926            self.path.push(AllowedProposers::EPOCH_FIELD.name);
11927            self.finish()
11928        }
11929        pub fn proposers(mut self) -> String {
11930            self.path.push(AllowedProposers::PROPOSERS_FIELD.name);
11931            self.finish()
11932        }
11933    }
11934    impl TransactionKind {
11935        pub const KIND_FIELD: &'static MessageField = &MessageField {
11936            name: "kind",
11937            json_name: "kind",
11938            number: 1i32,
11939            message_fields: None,
11940        };
11941        pub const PROGRAMMABLE_TRANSACTION_FIELD: &'static MessageField = &MessageField {
11942            name: "programmable_transaction",
11943            json_name: "programmableTransaction",
11944            number: 2i32,
11945            message_fields: Some(ProgrammableTransaction::FIELDS),
11946        };
11947        pub const CHANGE_EPOCH_FIELD: &'static MessageField = &MessageField {
11948            name: "change_epoch",
11949            json_name: "changeEpoch",
11950            number: 3i32,
11951            message_fields: Some(ChangeEpoch::FIELDS),
11952        };
11953        pub const GENESIS_FIELD: &'static MessageField = &MessageField {
11954            name: "genesis",
11955            json_name: "genesis",
11956            number: 4i32,
11957            message_fields: Some(GenesisTransaction::FIELDS),
11958        };
11959        pub const CONSENSUS_COMMIT_PROLOGUE_FIELD: &'static MessageField = &MessageField {
11960            name: "consensus_commit_prologue",
11961            json_name: "consensusCommitPrologue",
11962            number: 5i32,
11963            message_fields: Some(ConsensusCommitPrologue::FIELDS),
11964        };
11965        pub const AUTHENTICATOR_STATE_UPDATE_FIELD: &'static MessageField = &MessageField {
11966            name: "authenticator_state_update",
11967            json_name: "authenticatorStateUpdate",
11968            number: 6i32,
11969            message_fields: Some(AuthenticatorStateUpdate::FIELDS),
11970        };
11971        pub const END_OF_EPOCH_FIELD: &'static MessageField = &MessageField {
11972            name: "end_of_epoch",
11973            json_name: "endOfEpoch",
11974            number: 7i32,
11975            message_fields: Some(EndOfEpochTransaction::FIELDS),
11976        };
11977        pub const RANDOMNESS_STATE_UPDATE_FIELD: &'static MessageField = &MessageField {
11978            name: "randomness_state_update",
11979            json_name: "randomnessStateUpdate",
11980            number: 8i32,
11981            message_fields: Some(RandomnessStateUpdate::FIELDS),
11982        };
11983    }
11984    impl MessageFields for TransactionKind {
11985        const FIELDS: &'static [&'static MessageField] = &[
11986            Self::KIND_FIELD,
11987            Self::PROGRAMMABLE_TRANSACTION_FIELD,
11988            Self::CHANGE_EPOCH_FIELD,
11989            Self::GENESIS_FIELD,
11990            Self::CONSENSUS_COMMIT_PROLOGUE_FIELD,
11991            Self::AUTHENTICATOR_STATE_UPDATE_FIELD,
11992            Self::END_OF_EPOCH_FIELD,
11993            Self::RANDOMNESS_STATE_UPDATE_FIELD,
11994        ];
11995    }
11996    impl TransactionKind {
11997        pub fn path_builder() -> TransactionKindFieldPathBuilder {
11998            TransactionKindFieldPathBuilder::new()
11999        }
12000    }
12001    pub struct TransactionKindFieldPathBuilder {
12002        path: Vec<&'static str>,
12003    }
12004    impl TransactionKindFieldPathBuilder {
12005        #[allow(clippy::new_without_default)]
12006        pub fn new() -> Self {
12007            Self { path: Default::default() }
12008        }
12009        #[doc(hidden)]
12010        pub fn new_with_base(base: Vec<&'static str>) -> Self {
12011            Self { path: base }
12012        }
12013        pub fn finish(self) -> String {
12014            self.path.join(".")
12015        }
12016        pub fn kind(mut self) -> String {
12017            self.path.push(TransactionKind::KIND_FIELD.name);
12018            self.finish()
12019        }
12020        pub fn programmable_transaction(
12021            mut self,
12022        ) -> ProgrammableTransactionFieldPathBuilder {
12023            self.path.push(TransactionKind::PROGRAMMABLE_TRANSACTION_FIELD.name);
12024            ProgrammableTransactionFieldPathBuilder::new_with_base(self.path)
12025        }
12026        pub fn change_epoch(mut self) -> ChangeEpochFieldPathBuilder {
12027            self.path.push(TransactionKind::CHANGE_EPOCH_FIELD.name);
12028            ChangeEpochFieldPathBuilder::new_with_base(self.path)
12029        }
12030        pub fn genesis(mut self) -> GenesisTransactionFieldPathBuilder {
12031            self.path.push(TransactionKind::GENESIS_FIELD.name);
12032            GenesisTransactionFieldPathBuilder::new_with_base(self.path)
12033        }
12034        pub fn consensus_commit_prologue(
12035            mut self,
12036        ) -> ConsensusCommitPrologueFieldPathBuilder {
12037            self.path.push(TransactionKind::CONSENSUS_COMMIT_PROLOGUE_FIELD.name);
12038            ConsensusCommitPrologueFieldPathBuilder::new_with_base(self.path)
12039        }
12040        pub fn authenticator_state_update(
12041            mut self,
12042        ) -> AuthenticatorStateUpdateFieldPathBuilder {
12043            self.path.push(TransactionKind::AUTHENTICATOR_STATE_UPDATE_FIELD.name);
12044            AuthenticatorStateUpdateFieldPathBuilder::new_with_base(self.path)
12045        }
12046        pub fn end_of_epoch(mut self) -> EndOfEpochTransactionFieldPathBuilder {
12047            self.path.push(TransactionKind::END_OF_EPOCH_FIELD.name);
12048            EndOfEpochTransactionFieldPathBuilder::new_with_base(self.path)
12049        }
12050        pub fn randomness_state_update(
12051            mut self,
12052        ) -> RandomnessStateUpdateFieldPathBuilder {
12053            self.path.push(TransactionKind::RANDOMNESS_STATE_UPDATE_FIELD.name);
12054            RandomnessStateUpdateFieldPathBuilder::new_with_base(self.path)
12055        }
12056    }
12057    impl ProgrammableTransaction {
12058        pub const INPUTS_FIELD: &'static MessageField = &MessageField {
12059            name: "inputs",
12060            json_name: "inputs",
12061            number: 1i32,
12062            message_fields: Some(Input::FIELDS),
12063        };
12064        pub const COMMANDS_FIELD: &'static MessageField = &MessageField {
12065            name: "commands",
12066            json_name: "commands",
12067            number: 2i32,
12068            message_fields: Some(Command::FIELDS),
12069        };
12070    }
12071    impl MessageFields for ProgrammableTransaction {
12072        const FIELDS: &'static [&'static MessageField] = &[
12073            Self::INPUTS_FIELD,
12074            Self::COMMANDS_FIELD,
12075        ];
12076    }
12077    impl ProgrammableTransaction {
12078        pub fn path_builder() -> ProgrammableTransactionFieldPathBuilder {
12079            ProgrammableTransactionFieldPathBuilder::new()
12080        }
12081    }
12082    pub struct ProgrammableTransactionFieldPathBuilder {
12083        path: Vec<&'static str>,
12084    }
12085    impl ProgrammableTransactionFieldPathBuilder {
12086        #[allow(clippy::new_without_default)]
12087        pub fn new() -> Self {
12088            Self { path: Default::default() }
12089        }
12090        #[doc(hidden)]
12091        pub fn new_with_base(base: Vec<&'static str>) -> Self {
12092            Self { path: base }
12093        }
12094        pub fn finish(self) -> String {
12095            self.path.join(".")
12096        }
12097        pub fn inputs(mut self) -> InputFieldPathBuilder {
12098            self.path.push(ProgrammableTransaction::INPUTS_FIELD.name);
12099            InputFieldPathBuilder::new_with_base(self.path)
12100        }
12101        pub fn commands(mut self) -> CommandFieldPathBuilder {
12102            self.path.push(ProgrammableTransaction::COMMANDS_FIELD.name);
12103            CommandFieldPathBuilder::new_with_base(self.path)
12104        }
12105    }
12106    impl Command {
12107        pub const MOVE_CALL_FIELD: &'static MessageField = &MessageField {
12108            name: "move_call",
12109            json_name: "moveCall",
12110            number: 1i32,
12111            message_fields: Some(MoveCall::FIELDS),
12112        };
12113        pub const TRANSFER_OBJECTS_FIELD: &'static MessageField = &MessageField {
12114            name: "transfer_objects",
12115            json_name: "transferObjects",
12116            number: 2i32,
12117            message_fields: Some(TransferObjects::FIELDS),
12118        };
12119        pub const SPLIT_COINS_FIELD: &'static MessageField = &MessageField {
12120            name: "split_coins",
12121            json_name: "splitCoins",
12122            number: 3i32,
12123            message_fields: Some(SplitCoins::FIELDS),
12124        };
12125        pub const MERGE_COINS_FIELD: &'static MessageField = &MessageField {
12126            name: "merge_coins",
12127            json_name: "mergeCoins",
12128            number: 4i32,
12129            message_fields: Some(MergeCoins::FIELDS),
12130        };
12131        pub const PUBLISH_FIELD: &'static MessageField = &MessageField {
12132            name: "publish",
12133            json_name: "publish",
12134            number: 5i32,
12135            message_fields: Some(Publish::FIELDS),
12136        };
12137        pub const MAKE_MOVE_VECTOR_FIELD: &'static MessageField = &MessageField {
12138            name: "make_move_vector",
12139            json_name: "makeMoveVector",
12140            number: 6i32,
12141            message_fields: Some(MakeMoveVector::FIELDS),
12142        };
12143        pub const UPGRADE_FIELD: &'static MessageField = &MessageField {
12144            name: "upgrade",
12145            json_name: "upgrade",
12146            number: 7i32,
12147            message_fields: Some(Upgrade::FIELDS),
12148        };
12149    }
12150    impl MessageFields for Command {
12151        const FIELDS: &'static [&'static MessageField] = &[
12152            Self::MOVE_CALL_FIELD,
12153            Self::TRANSFER_OBJECTS_FIELD,
12154            Self::SPLIT_COINS_FIELD,
12155            Self::MERGE_COINS_FIELD,
12156            Self::PUBLISH_FIELD,
12157            Self::MAKE_MOVE_VECTOR_FIELD,
12158            Self::UPGRADE_FIELD,
12159        ];
12160    }
12161    impl Command {
12162        pub fn path_builder() -> CommandFieldPathBuilder {
12163            CommandFieldPathBuilder::new()
12164        }
12165    }
12166    pub struct CommandFieldPathBuilder {
12167        path: Vec<&'static str>,
12168    }
12169    impl CommandFieldPathBuilder {
12170        #[allow(clippy::new_without_default)]
12171        pub fn new() -> Self {
12172            Self { path: Default::default() }
12173        }
12174        #[doc(hidden)]
12175        pub fn new_with_base(base: Vec<&'static str>) -> Self {
12176            Self { path: base }
12177        }
12178        pub fn finish(self) -> String {
12179            self.path.join(".")
12180        }
12181        pub fn move_call(mut self) -> MoveCallFieldPathBuilder {
12182            self.path.push(Command::MOVE_CALL_FIELD.name);
12183            MoveCallFieldPathBuilder::new_with_base(self.path)
12184        }
12185        pub fn transfer_objects(mut self) -> TransferObjectsFieldPathBuilder {
12186            self.path.push(Command::TRANSFER_OBJECTS_FIELD.name);
12187            TransferObjectsFieldPathBuilder::new_with_base(self.path)
12188        }
12189        pub fn split_coins(mut self) -> SplitCoinsFieldPathBuilder {
12190            self.path.push(Command::SPLIT_COINS_FIELD.name);
12191            SplitCoinsFieldPathBuilder::new_with_base(self.path)
12192        }
12193        pub fn merge_coins(mut self) -> MergeCoinsFieldPathBuilder {
12194            self.path.push(Command::MERGE_COINS_FIELD.name);
12195            MergeCoinsFieldPathBuilder::new_with_base(self.path)
12196        }
12197        pub fn publish(mut self) -> PublishFieldPathBuilder {
12198            self.path.push(Command::PUBLISH_FIELD.name);
12199            PublishFieldPathBuilder::new_with_base(self.path)
12200        }
12201        pub fn make_move_vector(mut self) -> MakeMoveVectorFieldPathBuilder {
12202            self.path.push(Command::MAKE_MOVE_VECTOR_FIELD.name);
12203            MakeMoveVectorFieldPathBuilder::new_with_base(self.path)
12204        }
12205        pub fn upgrade(mut self) -> UpgradeFieldPathBuilder {
12206            self.path.push(Command::UPGRADE_FIELD.name);
12207            UpgradeFieldPathBuilder::new_with_base(self.path)
12208        }
12209    }
12210    impl MoveCall {
12211        pub const PACKAGE_FIELD: &'static MessageField = &MessageField {
12212            name: "package",
12213            json_name: "package",
12214            number: 1i32,
12215            message_fields: None,
12216        };
12217        pub const MODULE_FIELD: &'static MessageField = &MessageField {
12218            name: "module",
12219            json_name: "module",
12220            number: 2i32,
12221            message_fields: None,
12222        };
12223        pub const FUNCTION_FIELD: &'static MessageField = &MessageField {
12224            name: "function",
12225            json_name: "function",
12226            number: 3i32,
12227            message_fields: None,
12228        };
12229        pub const TYPE_ARGUMENTS_FIELD: &'static MessageField = &MessageField {
12230            name: "type_arguments",
12231            json_name: "typeArguments",
12232            number: 4i32,
12233            message_fields: None,
12234        };
12235        pub const ARGUMENTS_FIELD: &'static MessageField = &MessageField {
12236            name: "arguments",
12237            json_name: "arguments",
12238            number: 5i32,
12239            message_fields: Some(Argument::FIELDS),
12240        };
12241    }
12242    impl MessageFields for MoveCall {
12243        const FIELDS: &'static [&'static MessageField] = &[
12244            Self::PACKAGE_FIELD,
12245            Self::MODULE_FIELD,
12246            Self::FUNCTION_FIELD,
12247            Self::TYPE_ARGUMENTS_FIELD,
12248            Self::ARGUMENTS_FIELD,
12249        ];
12250    }
12251    impl MoveCall {
12252        pub fn path_builder() -> MoveCallFieldPathBuilder {
12253            MoveCallFieldPathBuilder::new()
12254        }
12255    }
12256    pub struct MoveCallFieldPathBuilder {
12257        path: Vec<&'static str>,
12258    }
12259    impl MoveCallFieldPathBuilder {
12260        #[allow(clippy::new_without_default)]
12261        pub fn new() -> Self {
12262            Self { path: Default::default() }
12263        }
12264        #[doc(hidden)]
12265        pub fn new_with_base(base: Vec<&'static str>) -> Self {
12266            Self { path: base }
12267        }
12268        pub fn finish(self) -> String {
12269            self.path.join(".")
12270        }
12271        pub fn package(mut self) -> String {
12272            self.path.push(MoveCall::PACKAGE_FIELD.name);
12273            self.finish()
12274        }
12275        pub fn module(mut self) -> String {
12276            self.path.push(MoveCall::MODULE_FIELD.name);
12277            self.finish()
12278        }
12279        pub fn function(mut self) -> String {
12280            self.path.push(MoveCall::FUNCTION_FIELD.name);
12281            self.finish()
12282        }
12283        pub fn type_arguments(mut self) -> String {
12284            self.path.push(MoveCall::TYPE_ARGUMENTS_FIELD.name);
12285            self.finish()
12286        }
12287        pub fn arguments(mut self) -> ArgumentFieldPathBuilder {
12288            self.path.push(MoveCall::ARGUMENTS_FIELD.name);
12289            ArgumentFieldPathBuilder::new_with_base(self.path)
12290        }
12291    }
12292    impl TransferObjects {
12293        pub const OBJECTS_FIELD: &'static MessageField = &MessageField {
12294            name: "objects",
12295            json_name: "objects",
12296            number: 1i32,
12297            message_fields: Some(Argument::FIELDS),
12298        };
12299        pub const ADDRESS_FIELD: &'static MessageField = &MessageField {
12300            name: "address",
12301            json_name: "address",
12302            number: 2i32,
12303            message_fields: Some(Argument::FIELDS),
12304        };
12305    }
12306    impl MessageFields for TransferObjects {
12307        const FIELDS: &'static [&'static MessageField] = &[
12308            Self::OBJECTS_FIELD,
12309            Self::ADDRESS_FIELD,
12310        ];
12311    }
12312    impl TransferObjects {
12313        pub fn path_builder() -> TransferObjectsFieldPathBuilder {
12314            TransferObjectsFieldPathBuilder::new()
12315        }
12316    }
12317    pub struct TransferObjectsFieldPathBuilder {
12318        path: Vec<&'static str>,
12319    }
12320    impl TransferObjectsFieldPathBuilder {
12321        #[allow(clippy::new_without_default)]
12322        pub fn new() -> Self {
12323            Self { path: Default::default() }
12324        }
12325        #[doc(hidden)]
12326        pub fn new_with_base(base: Vec<&'static str>) -> Self {
12327            Self { path: base }
12328        }
12329        pub fn finish(self) -> String {
12330            self.path.join(".")
12331        }
12332        pub fn objects(mut self) -> ArgumentFieldPathBuilder {
12333            self.path.push(TransferObjects::OBJECTS_FIELD.name);
12334            ArgumentFieldPathBuilder::new_with_base(self.path)
12335        }
12336        pub fn address(mut self) -> ArgumentFieldPathBuilder {
12337            self.path.push(TransferObjects::ADDRESS_FIELD.name);
12338            ArgumentFieldPathBuilder::new_with_base(self.path)
12339        }
12340    }
12341    impl SplitCoins {
12342        pub const COIN_FIELD: &'static MessageField = &MessageField {
12343            name: "coin",
12344            json_name: "coin",
12345            number: 1i32,
12346            message_fields: Some(Argument::FIELDS),
12347        };
12348        pub const AMOUNTS_FIELD: &'static MessageField = &MessageField {
12349            name: "amounts",
12350            json_name: "amounts",
12351            number: 2i32,
12352            message_fields: Some(Argument::FIELDS),
12353        };
12354    }
12355    impl MessageFields for SplitCoins {
12356        const FIELDS: &'static [&'static MessageField] = &[
12357            Self::COIN_FIELD,
12358            Self::AMOUNTS_FIELD,
12359        ];
12360    }
12361    impl SplitCoins {
12362        pub fn path_builder() -> SplitCoinsFieldPathBuilder {
12363            SplitCoinsFieldPathBuilder::new()
12364        }
12365    }
12366    pub struct SplitCoinsFieldPathBuilder {
12367        path: Vec<&'static str>,
12368    }
12369    impl SplitCoinsFieldPathBuilder {
12370        #[allow(clippy::new_without_default)]
12371        pub fn new() -> Self {
12372            Self { path: Default::default() }
12373        }
12374        #[doc(hidden)]
12375        pub fn new_with_base(base: Vec<&'static str>) -> Self {
12376            Self { path: base }
12377        }
12378        pub fn finish(self) -> String {
12379            self.path.join(".")
12380        }
12381        pub fn coin(mut self) -> ArgumentFieldPathBuilder {
12382            self.path.push(SplitCoins::COIN_FIELD.name);
12383            ArgumentFieldPathBuilder::new_with_base(self.path)
12384        }
12385        pub fn amounts(mut self) -> ArgumentFieldPathBuilder {
12386            self.path.push(SplitCoins::AMOUNTS_FIELD.name);
12387            ArgumentFieldPathBuilder::new_with_base(self.path)
12388        }
12389    }
12390    impl MergeCoins {
12391        pub const COIN_FIELD: &'static MessageField = &MessageField {
12392            name: "coin",
12393            json_name: "coin",
12394            number: 1i32,
12395            message_fields: Some(Argument::FIELDS),
12396        };
12397        pub const COINS_TO_MERGE_FIELD: &'static MessageField = &MessageField {
12398            name: "coins_to_merge",
12399            json_name: "coinsToMerge",
12400            number: 2i32,
12401            message_fields: Some(Argument::FIELDS),
12402        };
12403    }
12404    impl MessageFields for MergeCoins {
12405        const FIELDS: &'static [&'static MessageField] = &[
12406            Self::COIN_FIELD,
12407            Self::COINS_TO_MERGE_FIELD,
12408        ];
12409    }
12410    impl MergeCoins {
12411        pub fn path_builder() -> MergeCoinsFieldPathBuilder {
12412            MergeCoinsFieldPathBuilder::new()
12413        }
12414    }
12415    pub struct MergeCoinsFieldPathBuilder {
12416        path: Vec<&'static str>,
12417    }
12418    impl MergeCoinsFieldPathBuilder {
12419        #[allow(clippy::new_without_default)]
12420        pub fn new() -> Self {
12421            Self { path: Default::default() }
12422        }
12423        #[doc(hidden)]
12424        pub fn new_with_base(base: Vec<&'static str>) -> Self {
12425            Self { path: base }
12426        }
12427        pub fn finish(self) -> String {
12428            self.path.join(".")
12429        }
12430        pub fn coin(mut self) -> ArgumentFieldPathBuilder {
12431            self.path.push(MergeCoins::COIN_FIELD.name);
12432            ArgumentFieldPathBuilder::new_with_base(self.path)
12433        }
12434        pub fn coins_to_merge(mut self) -> ArgumentFieldPathBuilder {
12435            self.path.push(MergeCoins::COINS_TO_MERGE_FIELD.name);
12436            ArgumentFieldPathBuilder::new_with_base(self.path)
12437        }
12438    }
12439    impl Publish {
12440        pub const MODULES_FIELD: &'static MessageField = &MessageField {
12441            name: "modules",
12442            json_name: "modules",
12443            number: 1i32,
12444            message_fields: None,
12445        };
12446        pub const DEPENDENCIES_FIELD: &'static MessageField = &MessageField {
12447            name: "dependencies",
12448            json_name: "dependencies",
12449            number: 2i32,
12450            message_fields: None,
12451        };
12452    }
12453    impl MessageFields for Publish {
12454        const FIELDS: &'static [&'static MessageField] = &[
12455            Self::MODULES_FIELD,
12456            Self::DEPENDENCIES_FIELD,
12457        ];
12458    }
12459    impl Publish {
12460        pub fn path_builder() -> PublishFieldPathBuilder {
12461            PublishFieldPathBuilder::new()
12462        }
12463    }
12464    pub struct PublishFieldPathBuilder {
12465        path: Vec<&'static str>,
12466    }
12467    impl PublishFieldPathBuilder {
12468        #[allow(clippy::new_without_default)]
12469        pub fn new() -> Self {
12470            Self { path: Default::default() }
12471        }
12472        #[doc(hidden)]
12473        pub fn new_with_base(base: Vec<&'static str>) -> Self {
12474            Self { path: base }
12475        }
12476        pub fn finish(self) -> String {
12477            self.path.join(".")
12478        }
12479        pub fn modules(mut self) -> String {
12480            self.path.push(Publish::MODULES_FIELD.name);
12481            self.finish()
12482        }
12483        pub fn dependencies(mut self) -> String {
12484            self.path.push(Publish::DEPENDENCIES_FIELD.name);
12485            self.finish()
12486        }
12487    }
12488    impl MakeMoveVector {
12489        pub const ELEMENT_TYPE_FIELD: &'static MessageField = &MessageField {
12490            name: "element_type",
12491            json_name: "elementType",
12492            number: 1i32,
12493            message_fields: None,
12494        };
12495        pub const ELEMENTS_FIELD: &'static MessageField = &MessageField {
12496            name: "elements",
12497            json_name: "elements",
12498            number: 2i32,
12499            message_fields: Some(Argument::FIELDS),
12500        };
12501    }
12502    impl MessageFields for MakeMoveVector {
12503        const FIELDS: &'static [&'static MessageField] = &[
12504            Self::ELEMENT_TYPE_FIELD,
12505            Self::ELEMENTS_FIELD,
12506        ];
12507    }
12508    impl MakeMoveVector {
12509        pub fn path_builder() -> MakeMoveVectorFieldPathBuilder {
12510            MakeMoveVectorFieldPathBuilder::new()
12511        }
12512    }
12513    pub struct MakeMoveVectorFieldPathBuilder {
12514        path: Vec<&'static str>,
12515    }
12516    impl MakeMoveVectorFieldPathBuilder {
12517        #[allow(clippy::new_without_default)]
12518        pub fn new() -> Self {
12519            Self { path: Default::default() }
12520        }
12521        #[doc(hidden)]
12522        pub fn new_with_base(base: Vec<&'static str>) -> Self {
12523            Self { path: base }
12524        }
12525        pub fn finish(self) -> String {
12526            self.path.join(".")
12527        }
12528        pub fn element_type(mut self) -> String {
12529            self.path.push(MakeMoveVector::ELEMENT_TYPE_FIELD.name);
12530            self.finish()
12531        }
12532        pub fn elements(mut self) -> ArgumentFieldPathBuilder {
12533            self.path.push(MakeMoveVector::ELEMENTS_FIELD.name);
12534            ArgumentFieldPathBuilder::new_with_base(self.path)
12535        }
12536    }
12537    impl Upgrade {
12538        pub const MODULES_FIELD: &'static MessageField = &MessageField {
12539            name: "modules",
12540            json_name: "modules",
12541            number: 1i32,
12542            message_fields: None,
12543        };
12544        pub const DEPENDENCIES_FIELD: &'static MessageField = &MessageField {
12545            name: "dependencies",
12546            json_name: "dependencies",
12547            number: 2i32,
12548            message_fields: None,
12549        };
12550        pub const PACKAGE_FIELD: &'static MessageField = &MessageField {
12551            name: "package",
12552            json_name: "package",
12553            number: 3i32,
12554            message_fields: None,
12555        };
12556        pub const TICKET_FIELD: &'static MessageField = &MessageField {
12557            name: "ticket",
12558            json_name: "ticket",
12559            number: 4i32,
12560            message_fields: Some(Argument::FIELDS),
12561        };
12562    }
12563    impl MessageFields for Upgrade {
12564        const FIELDS: &'static [&'static MessageField] = &[
12565            Self::MODULES_FIELD,
12566            Self::DEPENDENCIES_FIELD,
12567            Self::PACKAGE_FIELD,
12568            Self::TICKET_FIELD,
12569        ];
12570    }
12571    impl Upgrade {
12572        pub fn path_builder() -> UpgradeFieldPathBuilder {
12573            UpgradeFieldPathBuilder::new()
12574        }
12575    }
12576    pub struct UpgradeFieldPathBuilder {
12577        path: Vec<&'static str>,
12578    }
12579    impl UpgradeFieldPathBuilder {
12580        #[allow(clippy::new_without_default)]
12581        pub fn new() -> Self {
12582            Self { path: Default::default() }
12583        }
12584        #[doc(hidden)]
12585        pub fn new_with_base(base: Vec<&'static str>) -> Self {
12586            Self { path: base }
12587        }
12588        pub fn finish(self) -> String {
12589            self.path.join(".")
12590        }
12591        pub fn modules(mut self) -> String {
12592            self.path.push(Upgrade::MODULES_FIELD.name);
12593            self.finish()
12594        }
12595        pub fn dependencies(mut self) -> String {
12596            self.path.push(Upgrade::DEPENDENCIES_FIELD.name);
12597            self.finish()
12598        }
12599        pub fn package(mut self) -> String {
12600            self.path.push(Upgrade::PACKAGE_FIELD.name);
12601            self.finish()
12602        }
12603        pub fn ticket(mut self) -> ArgumentFieldPathBuilder {
12604            self.path.push(Upgrade::TICKET_FIELD.name);
12605            ArgumentFieldPathBuilder::new_with_base(self.path)
12606        }
12607    }
12608    impl RandomnessStateUpdate {
12609        pub const EPOCH_FIELD: &'static MessageField = &MessageField {
12610            name: "epoch",
12611            json_name: "epoch",
12612            number: 1i32,
12613            message_fields: None,
12614        };
12615        pub const RANDOMNESS_ROUND_FIELD: &'static MessageField = &MessageField {
12616            name: "randomness_round",
12617            json_name: "randomnessRound",
12618            number: 2i32,
12619            message_fields: None,
12620        };
12621        pub const RANDOM_BYTES_FIELD: &'static MessageField = &MessageField {
12622            name: "random_bytes",
12623            json_name: "randomBytes",
12624            number: 3i32,
12625            message_fields: None,
12626        };
12627        pub const RANDOMNESS_OBJECT_INITIAL_SHARED_VERSION_FIELD: &'static MessageField = &MessageField {
12628            name: "randomness_object_initial_shared_version",
12629            json_name: "randomnessObjectInitialSharedVersion",
12630            number: 4i32,
12631            message_fields: None,
12632        };
12633    }
12634    impl MessageFields for RandomnessStateUpdate {
12635        const FIELDS: &'static [&'static MessageField] = &[
12636            Self::EPOCH_FIELD,
12637            Self::RANDOMNESS_ROUND_FIELD,
12638            Self::RANDOM_BYTES_FIELD,
12639            Self::RANDOMNESS_OBJECT_INITIAL_SHARED_VERSION_FIELD,
12640        ];
12641    }
12642    impl RandomnessStateUpdate {
12643        pub fn path_builder() -> RandomnessStateUpdateFieldPathBuilder {
12644            RandomnessStateUpdateFieldPathBuilder::new()
12645        }
12646    }
12647    pub struct RandomnessStateUpdateFieldPathBuilder {
12648        path: Vec<&'static str>,
12649    }
12650    impl RandomnessStateUpdateFieldPathBuilder {
12651        #[allow(clippy::new_without_default)]
12652        pub fn new() -> Self {
12653            Self { path: Default::default() }
12654        }
12655        #[doc(hidden)]
12656        pub fn new_with_base(base: Vec<&'static str>) -> Self {
12657            Self { path: base }
12658        }
12659        pub fn finish(self) -> String {
12660            self.path.join(".")
12661        }
12662        pub fn epoch(mut self) -> String {
12663            self.path.push(RandomnessStateUpdate::EPOCH_FIELD.name);
12664            self.finish()
12665        }
12666        pub fn randomness_round(mut self) -> String {
12667            self.path.push(RandomnessStateUpdate::RANDOMNESS_ROUND_FIELD.name);
12668            self.finish()
12669        }
12670        pub fn random_bytes(mut self) -> String {
12671            self.path.push(RandomnessStateUpdate::RANDOM_BYTES_FIELD.name);
12672            self.finish()
12673        }
12674        pub fn randomness_object_initial_shared_version(mut self) -> String {
12675            self.path
12676                .push(
12677                    RandomnessStateUpdate::RANDOMNESS_OBJECT_INITIAL_SHARED_VERSION_FIELD
12678                        .name,
12679                );
12680            self.finish()
12681        }
12682    }
12683    impl ChangeEpoch {
12684        pub const EPOCH_FIELD: &'static MessageField = &MessageField {
12685            name: "epoch",
12686            json_name: "epoch",
12687            number: 1i32,
12688            message_fields: None,
12689        };
12690        pub const PROTOCOL_VERSION_FIELD: &'static MessageField = &MessageField {
12691            name: "protocol_version",
12692            json_name: "protocolVersion",
12693            number: 2i32,
12694            message_fields: None,
12695        };
12696        pub const STORAGE_CHARGE_FIELD: &'static MessageField = &MessageField {
12697            name: "storage_charge",
12698            json_name: "storageCharge",
12699            number: 3i32,
12700            message_fields: None,
12701        };
12702        pub const COMPUTATION_CHARGE_FIELD: &'static MessageField = &MessageField {
12703            name: "computation_charge",
12704            json_name: "computationCharge",
12705            number: 4i32,
12706            message_fields: None,
12707        };
12708        pub const STORAGE_REBATE_FIELD: &'static MessageField = &MessageField {
12709            name: "storage_rebate",
12710            json_name: "storageRebate",
12711            number: 5i32,
12712            message_fields: None,
12713        };
12714        pub const NON_REFUNDABLE_STORAGE_FEE_FIELD: &'static MessageField = &MessageField {
12715            name: "non_refundable_storage_fee",
12716            json_name: "nonRefundableStorageFee",
12717            number: 6i32,
12718            message_fields: None,
12719        };
12720        pub const EPOCH_START_TIMESTAMP_FIELD: &'static MessageField = &MessageField {
12721            name: "epoch_start_timestamp",
12722            json_name: "epochStartTimestamp",
12723            number: 7i32,
12724            message_fields: None,
12725        };
12726        pub const SYSTEM_PACKAGES_FIELD: &'static MessageField = &MessageField {
12727            name: "system_packages",
12728            json_name: "systemPackages",
12729            number: 8i32,
12730            message_fields: Some(SystemPackage::FIELDS),
12731        };
12732    }
12733    impl MessageFields for ChangeEpoch {
12734        const FIELDS: &'static [&'static MessageField] = &[
12735            Self::EPOCH_FIELD,
12736            Self::PROTOCOL_VERSION_FIELD,
12737            Self::STORAGE_CHARGE_FIELD,
12738            Self::COMPUTATION_CHARGE_FIELD,
12739            Self::STORAGE_REBATE_FIELD,
12740            Self::NON_REFUNDABLE_STORAGE_FEE_FIELD,
12741            Self::EPOCH_START_TIMESTAMP_FIELD,
12742            Self::SYSTEM_PACKAGES_FIELD,
12743        ];
12744    }
12745    impl ChangeEpoch {
12746        pub fn path_builder() -> ChangeEpochFieldPathBuilder {
12747            ChangeEpochFieldPathBuilder::new()
12748        }
12749    }
12750    pub struct ChangeEpochFieldPathBuilder {
12751        path: Vec<&'static str>,
12752    }
12753    impl ChangeEpochFieldPathBuilder {
12754        #[allow(clippy::new_without_default)]
12755        pub fn new() -> Self {
12756            Self { path: Default::default() }
12757        }
12758        #[doc(hidden)]
12759        pub fn new_with_base(base: Vec<&'static str>) -> Self {
12760            Self { path: base }
12761        }
12762        pub fn finish(self) -> String {
12763            self.path.join(".")
12764        }
12765        pub fn epoch(mut self) -> String {
12766            self.path.push(ChangeEpoch::EPOCH_FIELD.name);
12767            self.finish()
12768        }
12769        pub fn protocol_version(mut self) -> String {
12770            self.path.push(ChangeEpoch::PROTOCOL_VERSION_FIELD.name);
12771            self.finish()
12772        }
12773        pub fn storage_charge(mut self) -> String {
12774            self.path.push(ChangeEpoch::STORAGE_CHARGE_FIELD.name);
12775            self.finish()
12776        }
12777        pub fn computation_charge(mut self) -> String {
12778            self.path.push(ChangeEpoch::COMPUTATION_CHARGE_FIELD.name);
12779            self.finish()
12780        }
12781        pub fn storage_rebate(mut self) -> String {
12782            self.path.push(ChangeEpoch::STORAGE_REBATE_FIELD.name);
12783            self.finish()
12784        }
12785        pub fn non_refundable_storage_fee(mut self) -> String {
12786            self.path.push(ChangeEpoch::NON_REFUNDABLE_STORAGE_FEE_FIELD.name);
12787            self.finish()
12788        }
12789        pub fn epoch_start_timestamp(mut self) -> String {
12790            self.path.push(ChangeEpoch::EPOCH_START_TIMESTAMP_FIELD.name);
12791            self.finish()
12792        }
12793        pub fn system_packages(mut self) -> SystemPackageFieldPathBuilder {
12794            self.path.push(ChangeEpoch::SYSTEM_PACKAGES_FIELD.name);
12795            SystemPackageFieldPathBuilder::new_with_base(self.path)
12796        }
12797    }
12798    impl SystemPackage {
12799        pub const VERSION_FIELD: &'static MessageField = &MessageField {
12800            name: "version",
12801            json_name: "version",
12802            number: 1i32,
12803            message_fields: None,
12804        };
12805        pub const MODULES_FIELD: &'static MessageField = &MessageField {
12806            name: "modules",
12807            json_name: "modules",
12808            number: 2i32,
12809            message_fields: None,
12810        };
12811        pub const DEPENDENCIES_FIELD: &'static MessageField = &MessageField {
12812            name: "dependencies",
12813            json_name: "dependencies",
12814            number: 3i32,
12815            message_fields: None,
12816        };
12817    }
12818    impl MessageFields for SystemPackage {
12819        const FIELDS: &'static [&'static MessageField] = &[
12820            Self::VERSION_FIELD,
12821            Self::MODULES_FIELD,
12822            Self::DEPENDENCIES_FIELD,
12823        ];
12824    }
12825    impl SystemPackage {
12826        pub fn path_builder() -> SystemPackageFieldPathBuilder {
12827            SystemPackageFieldPathBuilder::new()
12828        }
12829    }
12830    pub struct SystemPackageFieldPathBuilder {
12831        path: Vec<&'static str>,
12832    }
12833    impl SystemPackageFieldPathBuilder {
12834        #[allow(clippy::new_without_default)]
12835        pub fn new() -> Self {
12836            Self { path: Default::default() }
12837        }
12838        #[doc(hidden)]
12839        pub fn new_with_base(base: Vec<&'static str>) -> Self {
12840            Self { path: base }
12841        }
12842        pub fn finish(self) -> String {
12843            self.path.join(".")
12844        }
12845        pub fn version(mut self) -> String {
12846            self.path.push(SystemPackage::VERSION_FIELD.name);
12847            self.finish()
12848        }
12849        pub fn modules(mut self) -> String {
12850            self.path.push(SystemPackage::MODULES_FIELD.name);
12851            self.finish()
12852        }
12853        pub fn dependencies(mut self) -> String {
12854            self.path.push(SystemPackage::DEPENDENCIES_FIELD.name);
12855            self.finish()
12856        }
12857    }
12858    impl GenesisTransaction {
12859        pub const OBJECTS_FIELD: &'static MessageField = &MessageField {
12860            name: "objects",
12861            json_name: "objects",
12862            number: 1i32,
12863            message_fields: Some(Object::FIELDS),
12864        };
12865    }
12866    impl MessageFields for GenesisTransaction {
12867        const FIELDS: &'static [&'static MessageField] = &[Self::OBJECTS_FIELD];
12868    }
12869    impl GenesisTransaction {
12870        pub fn path_builder() -> GenesisTransactionFieldPathBuilder {
12871            GenesisTransactionFieldPathBuilder::new()
12872        }
12873    }
12874    pub struct GenesisTransactionFieldPathBuilder {
12875        path: Vec<&'static str>,
12876    }
12877    impl GenesisTransactionFieldPathBuilder {
12878        #[allow(clippy::new_without_default)]
12879        pub fn new() -> Self {
12880            Self { path: Default::default() }
12881        }
12882        #[doc(hidden)]
12883        pub fn new_with_base(base: Vec<&'static str>) -> Self {
12884            Self { path: base }
12885        }
12886        pub fn finish(self) -> String {
12887            self.path.join(".")
12888        }
12889        pub fn objects(mut self) -> ObjectFieldPathBuilder {
12890            self.path.push(GenesisTransaction::OBJECTS_FIELD.name);
12891            ObjectFieldPathBuilder::new_with_base(self.path)
12892        }
12893    }
12894    impl ConsensusCommitPrologue {
12895        pub const EPOCH_FIELD: &'static MessageField = &MessageField {
12896            name: "epoch",
12897            json_name: "epoch",
12898            number: 1i32,
12899            message_fields: None,
12900        };
12901        pub const ROUND_FIELD: &'static MessageField = &MessageField {
12902            name: "round",
12903            json_name: "round",
12904            number: 2i32,
12905            message_fields: None,
12906        };
12907        pub const COMMIT_TIMESTAMP_FIELD: &'static MessageField = &MessageField {
12908            name: "commit_timestamp",
12909            json_name: "commitTimestamp",
12910            number: 3i32,
12911            message_fields: None,
12912        };
12913        pub const CONSENSUS_COMMIT_DIGEST_FIELD: &'static MessageField = &MessageField {
12914            name: "consensus_commit_digest",
12915            json_name: "consensusCommitDigest",
12916            number: 4i32,
12917            message_fields: None,
12918        };
12919        pub const SUB_DAG_INDEX_FIELD: &'static MessageField = &MessageField {
12920            name: "sub_dag_index",
12921            json_name: "subDagIndex",
12922            number: 5i32,
12923            message_fields: None,
12924        };
12925        pub const CONSENSUS_DETERMINED_VERSION_ASSIGNMENTS_FIELD: &'static MessageField = &MessageField {
12926            name: "consensus_determined_version_assignments",
12927            json_name: "consensusDeterminedVersionAssignments",
12928            number: 6i32,
12929            message_fields: Some(ConsensusDeterminedVersionAssignments::FIELDS),
12930        };
12931        pub const ADDITIONAL_STATE_DIGEST_FIELD: &'static MessageField = &MessageField {
12932            name: "additional_state_digest",
12933            json_name: "additionalStateDigest",
12934            number: 7i32,
12935            message_fields: None,
12936        };
12937    }
12938    impl MessageFields for ConsensusCommitPrologue {
12939        const FIELDS: &'static [&'static MessageField] = &[
12940            Self::EPOCH_FIELD,
12941            Self::ROUND_FIELD,
12942            Self::COMMIT_TIMESTAMP_FIELD,
12943            Self::CONSENSUS_COMMIT_DIGEST_FIELD,
12944            Self::SUB_DAG_INDEX_FIELD,
12945            Self::CONSENSUS_DETERMINED_VERSION_ASSIGNMENTS_FIELD,
12946            Self::ADDITIONAL_STATE_DIGEST_FIELD,
12947        ];
12948    }
12949    impl ConsensusCommitPrologue {
12950        pub fn path_builder() -> ConsensusCommitPrologueFieldPathBuilder {
12951            ConsensusCommitPrologueFieldPathBuilder::new()
12952        }
12953    }
12954    pub struct ConsensusCommitPrologueFieldPathBuilder {
12955        path: Vec<&'static str>,
12956    }
12957    impl ConsensusCommitPrologueFieldPathBuilder {
12958        #[allow(clippy::new_without_default)]
12959        pub fn new() -> Self {
12960            Self { path: Default::default() }
12961        }
12962        #[doc(hidden)]
12963        pub fn new_with_base(base: Vec<&'static str>) -> Self {
12964            Self { path: base }
12965        }
12966        pub fn finish(self) -> String {
12967            self.path.join(".")
12968        }
12969        pub fn epoch(mut self) -> String {
12970            self.path.push(ConsensusCommitPrologue::EPOCH_FIELD.name);
12971            self.finish()
12972        }
12973        pub fn round(mut self) -> String {
12974            self.path.push(ConsensusCommitPrologue::ROUND_FIELD.name);
12975            self.finish()
12976        }
12977        pub fn commit_timestamp(mut self) -> String {
12978            self.path.push(ConsensusCommitPrologue::COMMIT_TIMESTAMP_FIELD.name);
12979            self.finish()
12980        }
12981        pub fn consensus_commit_digest(mut self) -> String {
12982            self.path.push(ConsensusCommitPrologue::CONSENSUS_COMMIT_DIGEST_FIELD.name);
12983            self.finish()
12984        }
12985        pub fn sub_dag_index(mut self) -> String {
12986            self.path.push(ConsensusCommitPrologue::SUB_DAG_INDEX_FIELD.name);
12987            self.finish()
12988        }
12989        pub fn consensus_determined_version_assignments(
12990            mut self,
12991        ) -> ConsensusDeterminedVersionAssignmentsFieldPathBuilder {
12992            self.path
12993                .push(
12994                    ConsensusCommitPrologue::CONSENSUS_DETERMINED_VERSION_ASSIGNMENTS_FIELD
12995                        .name,
12996                );
12997            ConsensusDeterminedVersionAssignmentsFieldPathBuilder::new_with_base(
12998                self.path,
12999            )
13000        }
13001        pub fn additional_state_digest(mut self) -> String {
13002            self.path.push(ConsensusCommitPrologue::ADDITIONAL_STATE_DIGEST_FIELD.name);
13003            self.finish()
13004        }
13005    }
13006    impl VersionAssignment {
13007        pub const OBJECT_ID_FIELD: &'static MessageField = &MessageField {
13008            name: "object_id",
13009            json_name: "objectId",
13010            number: 1i32,
13011            message_fields: None,
13012        };
13013        pub const START_VERSION_FIELD: &'static MessageField = &MessageField {
13014            name: "start_version",
13015            json_name: "startVersion",
13016            number: 2i32,
13017            message_fields: None,
13018        };
13019        pub const VERSION_FIELD: &'static MessageField = &MessageField {
13020            name: "version",
13021            json_name: "version",
13022            number: 3i32,
13023            message_fields: None,
13024        };
13025    }
13026    impl MessageFields for VersionAssignment {
13027        const FIELDS: &'static [&'static MessageField] = &[
13028            Self::OBJECT_ID_FIELD,
13029            Self::START_VERSION_FIELD,
13030            Self::VERSION_FIELD,
13031        ];
13032    }
13033    impl VersionAssignment {
13034        pub fn path_builder() -> VersionAssignmentFieldPathBuilder {
13035            VersionAssignmentFieldPathBuilder::new()
13036        }
13037    }
13038    pub struct VersionAssignmentFieldPathBuilder {
13039        path: Vec<&'static str>,
13040    }
13041    impl VersionAssignmentFieldPathBuilder {
13042        #[allow(clippy::new_without_default)]
13043        pub fn new() -> Self {
13044            Self { path: Default::default() }
13045        }
13046        #[doc(hidden)]
13047        pub fn new_with_base(base: Vec<&'static str>) -> Self {
13048            Self { path: base }
13049        }
13050        pub fn finish(self) -> String {
13051            self.path.join(".")
13052        }
13053        pub fn object_id(mut self) -> String {
13054            self.path.push(VersionAssignment::OBJECT_ID_FIELD.name);
13055            self.finish()
13056        }
13057        pub fn start_version(mut self) -> String {
13058            self.path.push(VersionAssignment::START_VERSION_FIELD.name);
13059            self.finish()
13060        }
13061        pub fn version(mut self) -> String {
13062            self.path.push(VersionAssignment::VERSION_FIELD.name);
13063            self.finish()
13064        }
13065    }
13066    impl CanceledTransaction {
13067        pub const DIGEST_FIELD: &'static MessageField = &MessageField {
13068            name: "digest",
13069            json_name: "digest",
13070            number: 1i32,
13071            message_fields: None,
13072        };
13073        pub const VERSION_ASSIGNMENTS_FIELD: &'static MessageField = &MessageField {
13074            name: "version_assignments",
13075            json_name: "versionAssignments",
13076            number: 2i32,
13077            message_fields: Some(VersionAssignment::FIELDS),
13078        };
13079    }
13080    impl MessageFields for CanceledTransaction {
13081        const FIELDS: &'static [&'static MessageField] = &[
13082            Self::DIGEST_FIELD,
13083            Self::VERSION_ASSIGNMENTS_FIELD,
13084        ];
13085    }
13086    impl CanceledTransaction {
13087        pub fn path_builder() -> CanceledTransactionFieldPathBuilder {
13088            CanceledTransactionFieldPathBuilder::new()
13089        }
13090    }
13091    pub struct CanceledTransactionFieldPathBuilder {
13092        path: Vec<&'static str>,
13093    }
13094    impl CanceledTransactionFieldPathBuilder {
13095        #[allow(clippy::new_without_default)]
13096        pub fn new() -> Self {
13097            Self { path: Default::default() }
13098        }
13099        #[doc(hidden)]
13100        pub fn new_with_base(base: Vec<&'static str>) -> Self {
13101            Self { path: base }
13102        }
13103        pub fn finish(self) -> String {
13104            self.path.join(".")
13105        }
13106        pub fn digest(mut self) -> String {
13107            self.path.push(CanceledTransaction::DIGEST_FIELD.name);
13108            self.finish()
13109        }
13110        pub fn version_assignments(mut self) -> VersionAssignmentFieldPathBuilder {
13111            self.path.push(CanceledTransaction::VERSION_ASSIGNMENTS_FIELD.name);
13112            VersionAssignmentFieldPathBuilder::new_with_base(self.path)
13113        }
13114    }
13115    impl ConsensusDeterminedVersionAssignments {
13116        pub const VERSION_FIELD: &'static MessageField = &MessageField {
13117            name: "version",
13118            json_name: "version",
13119            number: 1i32,
13120            message_fields: None,
13121        };
13122        pub const CANCELED_TRANSACTIONS_FIELD: &'static MessageField = &MessageField {
13123            name: "canceled_transactions",
13124            json_name: "canceledTransactions",
13125            number: 3i32,
13126            message_fields: Some(CanceledTransaction::FIELDS),
13127        };
13128    }
13129    impl MessageFields for ConsensusDeterminedVersionAssignments {
13130        const FIELDS: &'static [&'static MessageField] = &[
13131            Self::VERSION_FIELD,
13132            Self::CANCELED_TRANSACTIONS_FIELD,
13133        ];
13134    }
13135    impl ConsensusDeterminedVersionAssignments {
13136        pub fn path_builder() -> ConsensusDeterminedVersionAssignmentsFieldPathBuilder {
13137            ConsensusDeterminedVersionAssignmentsFieldPathBuilder::new()
13138        }
13139    }
13140    pub struct ConsensusDeterminedVersionAssignmentsFieldPathBuilder {
13141        path: Vec<&'static str>,
13142    }
13143    impl ConsensusDeterminedVersionAssignmentsFieldPathBuilder {
13144        #[allow(clippy::new_without_default)]
13145        pub fn new() -> Self {
13146            Self { path: Default::default() }
13147        }
13148        #[doc(hidden)]
13149        pub fn new_with_base(base: Vec<&'static str>) -> Self {
13150            Self { path: base }
13151        }
13152        pub fn finish(self) -> String {
13153            self.path.join(".")
13154        }
13155        pub fn version(mut self) -> String {
13156            self.path.push(ConsensusDeterminedVersionAssignments::VERSION_FIELD.name);
13157            self.finish()
13158        }
13159        pub fn canceled_transactions(mut self) -> CanceledTransactionFieldPathBuilder {
13160            self.path
13161                .push(
13162                    ConsensusDeterminedVersionAssignments::CANCELED_TRANSACTIONS_FIELD
13163                        .name,
13164                );
13165            CanceledTransactionFieldPathBuilder::new_with_base(self.path)
13166        }
13167    }
13168    impl AuthenticatorStateUpdate {
13169        pub const EPOCH_FIELD: &'static MessageField = &MessageField {
13170            name: "epoch",
13171            json_name: "epoch",
13172            number: 1i32,
13173            message_fields: None,
13174        };
13175        pub const ROUND_FIELD: &'static MessageField = &MessageField {
13176            name: "round",
13177            json_name: "round",
13178            number: 2i32,
13179            message_fields: None,
13180        };
13181        pub const NEW_ACTIVE_JWKS_FIELD: &'static MessageField = &MessageField {
13182            name: "new_active_jwks",
13183            json_name: "newActiveJwks",
13184            number: 3i32,
13185            message_fields: Some(ActiveJwk::FIELDS),
13186        };
13187        pub const AUTHENTICATOR_OBJECT_INITIAL_SHARED_VERSION_FIELD: &'static MessageField = &MessageField {
13188            name: "authenticator_object_initial_shared_version",
13189            json_name: "authenticatorObjectInitialSharedVersion",
13190            number: 4i32,
13191            message_fields: None,
13192        };
13193    }
13194    impl MessageFields for AuthenticatorStateUpdate {
13195        const FIELDS: &'static [&'static MessageField] = &[
13196            Self::EPOCH_FIELD,
13197            Self::ROUND_FIELD,
13198            Self::NEW_ACTIVE_JWKS_FIELD,
13199            Self::AUTHENTICATOR_OBJECT_INITIAL_SHARED_VERSION_FIELD,
13200        ];
13201    }
13202    impl AuthenticatorStateUpdate {
13203        pub fn path_builder() -> AuthenticatorStateUpdateFieldPathBuilder {
13204            AuthenticatorStateUpdateFieldPathBuilder::new()
13205        }
13206    }
13207    pub struct AuthenticatorStateUpdateFieldPathBuilder {
13208        path: Vec<&'static str>,
13209    }
13210    impl AuthenticatorStateUpdateFieldPathBuilder {
13211        #[allow(clippy::new_without_default)]
13212        pub fn new() -> Self {
13213            Self { path: Default::default() }
13214        }
13215        #[doc(hidden)]
13216        pub fn new_with_base(base: Vec<&'static str>) -> Self {
13217            Self { path: base }
13218        }
13219        pub fn finish(self) -> String {
13220            self.path.join(".")
13221        }
13222        pub fn epoch(mut self) -> String {
13223            self.path.push(AuthenticatorStateUpdate::EPOCH_FIELD.name);
13224            self.finish()
13225        }
13226        pub fn round(mut self) -> String {
13227            self.path.push(AuthenticatorStateUpdate::ROUND_FIELD.name);
13228            self.finish()
13229        }
13230        pub fn new_active_jwks(mut self) -> ActiveJwkFieldPathBuilder {
13231            self.path.push(AuthenticatorStateUpdate::NEW_ACTIVE_JWKS_FIELD.name);
13232            ActiveJwkFieldPathBuilder::new_with_base(self.path)
13233        }
13234        pub fn authenticator_object_initial_shared_version(mut self) -> String {
13235            self.path
13236                .push(
13237                    AuthenticatorStateUpdate::AUTHENTICATOR_OBJECT_INITIAL_SHARED_VERSION_FIELD
13238                        .name,
13239                );
13240            self.finish()
13241        }
13242    }
13243    impl ActiveJwk {
13244        pub const ID_FIELD: &'static MessageField = &MessageField {
13245            name: "id",
13246            json_name: "id",
13247            number: 1i32,
13248            message_fields: Some(JwkId::FIELDS),
13249        };
13250        pub const JWK_FIELD: &'static MessageField = &MessageField {
13251            name: "jwk",
13252            json_name: "jwk",
13253            number: 2i32,
13254            message_fields: Some(Jwk::FIELDS),
13255        };
13256        pub const EPOCH_FIELD: &'static MessageField = &MessageField {
13257            name: "epoch",
13258            json_name: "epoch",
13259            number: 3i32,
13260            message_fields: None,
13261        };
13262    }
13263    impl MessageFields for ActiveJwk {
13264        const FIELDS: &'static [&'static MessageField] = &[
13265            Self::ID_FIELD,
13266            Self::JWK_FIELD,
13267            Self::EPOCH_FIELD,
13268        ];
13269    }
13270    impl ActiveJwk {
13271        pub fn path_builder() -> ActiveJwkFieldPathBuilder {
13272            ActiveJwkFieldPathBuilder::new()
13273        }
13274    }
13275    pub struct ActiveJwkFieldPathBuilder {
13276        path: Vec<&'static str>,
13277    }
13278    impl ActiveJwkFieldPathBuilder {
13279        #[allow(clippy::new_without_default)]
13280        pub fn new() -> Self {
13281            Self { path: Default::default() }
13282        }
13283        #[doc(hidden)]
13284        pub fn new_with_base(base: Vec<&'static str>) -> Self {
13285            Self { path: base }
13286        }
13287        pub fn finish(self) -> String {
13288            self.path.join(".")
13289        }
13290        pub fn id(mut self) -> JwkIdFieldPathBuilder {
13291            self.path.push(ActiveJwk::ID_FIELD.name);
13292            JwkIdFieldPathBuilder::new_with_base(self.path)
13293        }
13294        pub fn jwk(mut self) -> JwkFieldPathBuilder {
13295            self.path.push(ActiveJwk::JWK_FIELD.name);
13296            JwkFieldPathBuilder::new_with_base(self.path)
13297        }
13298        pub fn epoch(mut self) -> String {
13299            self.path.push(ActiveJwk::EPOCH_FIELD.name);
13300            self.finish()
13301        }
13302    }
13303    impl EndOfEpochTransaction {
13304        pub const TRANSACTIONS_FIELD: &'static MessageField = &MessageField {
13305            name: "transactions",
13306            json_name: "transactions",
13307            number: 1i32,
13308            message_fields: Some(EndOfEpochTransactionKind::FIELDS),
13309        };
13310    }
13311    impl MessageFields for EndOfEpochTransaction {
13312        const FIELDS: &'static [&'static MessageField] = &[Self::TRANSACTIONS_FIELD];
13313    }
13314    impl EndOfEpochTransaction {
13315        pub fn path_builder() -> EndOfEpochTransactionFieldPathBuilder {
13316            EndOfEpochTransactionFieldPathBuilder::new()
13317        }
13318    }
13319    pub struct EndOfEpochTransactionFieldPathBuilder {
13320        path: Vec<&'static str>,
13321    }
13322    impl EndOfEpochTransactionFieldPathBuilder {
13323        #[allow(clippy::new_without_default)]
13324        pub fn new() -> Self {
13325            Self { path: Default::default() }
13326        }
13327        #[doc(hidden)]
13328        pub fn new_with_base(base: Vec<&'static str>) -> Self {
13329            Self { path: base }
13330        }
13331        pub fn finish(self) -> String {
13332            self.path.join(".")
13333        }
13334        pub fn transactions(mut self) -> EndOfEpochTransactionKindFieldPathBuilder {
13335            self.path.push(EndOfEpochTransaction::TRANSACTIONS_FIELD.name);
13336            EndOfEpochTransactionKindFieldPathBuilder::new_with_base(self.path)
13337        }
13338    }
13339    impl EndOfEpochTransactionKind {
13340        pub const KIND_FIELD: &'static MessageField = &MessageField {
13341            name: "kind",
13342            json_name: "kind",
13343            number: 1i32,
13344            message_fields: None,
13345        };
13346        pub const CHANGE_EPOCH_FIELD: &'static MessageField = &MessageField {
13347            name: "change_epoch",
13348            json_name: "changeEpoch",
13349            number: 2i32,
13350            message_fields: Some(ChangeEpoch::FIELDS),
13351        };
13352        pub const AUTHENTICATOR_STATE_EXPIRE_FIELD: &'static MessageField = &MessageField {
13353            name: "authenticator_state_expire",
13354            json_name: "authenticatorStateExpire",
13355            number: 3i32,
13356            message_fields: Some(AuthenticatorStateExpire::FIELDS),
13357        };
13358        pub const EXECUTION_TIME_OBSERVATIONS_FIELD: &'static MessageField = &MessageField {
13359            name: "execution_time_observations",
13360            json_name: "executionTimeObservations",
13361            number: 4i32,
13362            message_fields: Some(ExecutionTimeObservations::FIELDS),
13363        };
13364        pub const BRIDGE_CHAIN_ID_FIELD: &'static MessageField = &MessageField {
13365            name: "bridge_chain_id",
13366            json_name: "bridgeChainId",
13367            number: 5i32,
13368            message_fields: None,
13369        };
13370        pub const BRIDGE_OBJECT_VERSION_FIELD: &'static MessageField = &MessageField {
13371            name: "bridge_object_version",
13372            json_name: "bridgeObjectVersion",
13373            number: 6i32,
13374            message_fields: None,
13375        };
13376        pub const STORAGE_COST_FIELD: &'static MessageField = &MessageField {
13377            name: "storage_cost",
13378            json_name: "storageCost",
13379            number: 7i32,
13380            message_fields: None,
13381        };
13382    }
13383    impl MessageFields for EndOfEpochTransactionKind {
13384        const FIELDS: &'static [&'static MessageField] = &[
13385            Self::KIND_FIELD,
13386            Self::CHANGE_EPOCH_FIELD,
13387            Self::AUTHENTICATOR_STATE_EXPIRE_FIELD,
13388            Self::EXECUTION_TIME_OBSERVATIONS_FIELD,
13389            Self::BRIDGE_CHAIN_ID_FIELD,
13390            Self::BRIDGE_OBJECT_VERSION_FIELD,
13391            Self::STORAGE_COST_FIELD,
13392        ];
13393    }
13394    impl EndOfEpochTransactionKind {
13395        pub fn path_builder() -> EndOfEpochTransactionKindFieldPathBuilder {
13396            EndOfEpochTransactionKindFieldPathBuilder::new()
13397        }
13398    }
13399    pub struct EndOfEpochTransactionKindFieldPathBuilder {
13400        path: Vec<&'static str>,
13401    }
13402    impl EndOfEpochTransactionKindFieldPathBuilder {
13403        #[allow(clippy::new_without_default)]
13404        pub fn new() -> Self {
13405            Self { path: Default::default() }
13406        }
13407        #[doc(hidden)]
13408        pub fn new_with_base(base: Vec<&'static str>) -> Self {
13409            Self { path: base }
13410        }
13411        pub fn finish(self) -> String {
13412            self.path.join(".")
13413        }
13414        pub fn kind(mut self) -> String {
13415            self.path.push(EndOfEpochTransactionKind::KIND_FIELD.name);
13416            self.finish()
13417        }
13418        pub fn change_epoch(mut self) -> ChangeEpochFieldPathBuilder {
13419            self.path.push(EndOfEpochTransactionKind::CHANGE_EPOCH_FIELD.name);
13420            ChangeEpochFieldPathBuilder::new_with_base(self.path)
13421        }
13422        pub fn authenticator_state_expire(
13423            mut self,
13424        ) -> AuthenticatorStateExpireFieldPathBuilder {
13425            self.path
13426                .push(EndOfEpochTransactionKind::AUTHENTICATOR_STATE_EXPIRE_FIELD.name);
13427            AuthenticatorStateExpireFieldPathBuilder::new_with_base(self.path)
13428        }
13429        pub fn execution_time_observations(
13430            mut self,
13431        ) -> ExecutionTimeObservationsFieldPathBuilder {
13432            self.path
13433                .push(EndOfEpochTransactionKind::EXECUTION_TIME_OBSERVATIONS_FIELD.name);
13434            ExecutionTimeObservationsFieldPathBuilder::new_with_base(self.path)
13435        }
13436        pub fn bridge_chain_id(mut self) -> String {
13437            self.path.push(EndOfEpochTransactionKind::BRIDGE_CHAIN_ID_FIELD.name);
13438            self.finish()
13439        }
13440        pub fn bridge_object_version(mut self) -> String {
13441            self.path.push(EndOfEpochTransactionKind::BRIDGE_OBJECT_VERSION_FIELD.name);
13442            self.finish()
13443        }
13444        pub fn storage_cost(mut self) -> String {
13445            self.path.push(EndOfEpochTransactionKind::STORAGE_COST_FIELD.name);
13446            self.finish()
13447        }
13448    }
13449    impl AuthenticatorStateExpire {
13450        pub const MIN_EPOCH_FIELD: &'static MessageField = &MessageField {
13451            name: "min_epoch",
13452            json_name: "minEpoch",
13453            number: 1i32,
13454            message_fields: None,
13455        };
13456        pub const AUTHENTICATOR_OBJECT_INITIAL_SHARED_VERSION_FIELD: &'static MessageField = &MessageField {
13457            name: "authenticator_object_initial_shared_version",
13458            json_name: "authenticatorObjectInitialSharedVersion",
13459            number: 2i32,
13460            message_fields: None,
13461        };
13462    }
13463    impl MessageFields for AuthenticatorStateExpire {
13464        const FIELDS: &'static [&'static MessageField] = &[
13465            Self::MIN_EPOCH_FIELD,
13466            Self::AUTHENTICATOR_OBJECT_INITIAL_SHARED_VERSION_FIELD,
13467        ];
13468    }
13469    impl AuthenticatorStateExpire {
13470        pub fn path_builder() -> AuthenticatorStateExpireFieldPathBuilder {
13471            AuthenticatorStateExpireFieldPathBuilder::new()
13472        }
13473    }
13474    pub struct AuthenticatorStateExpireFieldPathBuilder {
13475        path: Vec<&'static str>,
13476    }
13477    impl AuthenticatorStateExpireFieldPathBuilder {
13478        #[allow(clippy::new_without_default)]
13479        pub fn new() -> Self {
13480            Self { path: Default::default() }
13481        }
13482        #[doc(hidden)]
13483        pub fn new_with_base(base: Vec<&'static str>) -> Self {
13484            Self { path: base }
13485        }
13486        pub fn finish(self) -> String {
13487            self.path.join(".")
13488        }
13489        pub fn min_epoch(mut self) -> String {
13490            self.path.push(AuthenticatorStateExpire::MIN_EPOCH_FIELD.name);
13491            self.finish()
13492        }
13493        pub fn authenticator_object_initial_shared_version(mut self) -> String {
13494            self.path
13495                .push(
13496                    AuthenticatorStateExpire::AUTHENTICATOR_OBJECT_INITIAL_SHARED_VERSION_FIELD
13497                        .name,
13498                );
13499            self.finish()
13500        }
13501    }
13502    impl ExecutionTimeObservations {
13503        pub const VERSION_FIELD: &'static MessageField = &MessageField {
13504            name: "version",
13505            json_name: "version",
13506            number: 1i32,
13507            message_fields: None,
13508        };
13509        pub const OBSERVATIONS_FIELD: &'static MessageField = &MessageField {
13510            name: "observations",
13511            json_name: "observations",
13512            number: 2i32,
13513            message_fields: Some(ExecutionTimeObservation::FIELDS),
13514        };
13515    }
13516    impl MessageFields for ExecutionTimeObservations {
13517        const FIELDS: &'static [&'static MessageField] = &[
13518            Self::VERSION_FIELD,
13519            Self::OBSERVATIONS_FIELD,
13520        ];
13521    }
13522    impl ExecutionTimeObservations {
13523        pub fn path_builder() -> ExecutionTimeObservationsFieldPathBuilder {
13524            ExecutionTimeObservationsFieldPathBuilder::new()
13525        }
13526    }
13527    pub struct ExecutionTimeObservationsFieldPathBuilder {
13528        path: Vec<&'static str>,
13529    }
13530    impl ExecutionTimeObservationsFieldPathBuilder {
13531        #[allow(clippy::new_without_default)]
13532        pub fn new() -> Self {
13533            Self { path: Default::default() }
13534        }
13535        #[doc(hidden)]
13536        pub fn new_with_base(base: Vec<&'static str>) -> Self {
13537            Self { path: base }
13538        }
13539        pub fn finish(self) -> String {
13540            self.path.join(".")
13541        }
13542        pub fn version(mut self) -> String {
13543            self.path.push(ExecutionTimeObservations::VERSION_FIELD.name);
13544            self.finish()
13545        }
13546        pub fn observations(mut self) -> ExecutionTimeObservationFieldPathBuilder {
13547            self.path.push(ExecutionTimeObservations::OBSERVATIONS_FIELD.name);
13548            ExecutionTimeObservationFieldPathBuilder::new_with_base(self.path)
13549        }
13550    }
13551    impl ExecutionTimeObservation {
13552        pub const KIND_FIELD: &'static MessageField = &MessageField {
13553            name: "kind",
13554            json_name: "kind",
13555            number: 1i32,
13556            message_fields: None,
13557        };
13558        pub const MOVE_ENTRY_POINT_FIELD: &'static MessageField = &MessageField {
13559            name: "move_entry_point",
13560            json_name: "moveEntryPoint",
13561            number: 2i32,
13562            message_fields: Some(MoveCall::FIELDS),
13563        };
13564        pub const VALIDATOR_OBSERVATIONS_FIELD: &'static MessageField = &MessageField {
13565            name: "validator_observations",
13566            json_name: "validatorObservations",
13567            number: 3i32,
13568            message_fields: Some(ValidatorExecutionTimeObservation::FIELDS),
13569        };
13570    }
13571    impl MessageFields for ExecutionTimeObservation {
13572        const FIELDS: &'static [&'static MessageField] = &[
13573            Self::KIND_FIELD,
13574            Self::MOVE_ENTRY_POINT_FIELD,
13575            Self::VALIDATOR_OBSERVATIONS_FIELD,
13576        ];
13577    }
13578    impl ExecutionTimeObservation {
13579        pub fn path_builder() -> ExecutionTimeObservationFieldPathBuilder {
13580            ExecutionTimeObservationFieldPathBuilder::new()
13581        }
13582    }
13583    pub struct ExecutionTimeObservationFieldPathBuilder {
13584        path: Vec<&'static str>,
13585    }
13586    impl ExecutionTimeObservationFieldPathBuilder {
13587        #[allow(clippy::new_without_default)]
13588        pub fn new() -> Self {
13589            Self { path: Default::default() }
13590        }
13591        #[doc(hidden)]
13592        pub fn new_with_base(base: Vec<&'static str>) -> Self {
13593            Self { path: base }
13594        }
13595        pub fn finish(self) -> String {
13596            self.path.join(".")
13597        }
13598        pub fn kind(mut self) -> String {
13599            self.path.push(ExecutionTimeObservation::KIND_FIELD.name);
13600            self.finish()
13601        }
13602        pub fn move_entry_point(mut self) -> MoveCallFieldPathBuilder {
13603            self.path.push(ExecutionTimeObservation::MOVE_ENTRY_POINT_FIELD.name);
13604            MoveCallFieldPathBuilder::new_with_base(self.path)
13605        }
13606        pub fn validator_observations(
13607            mut self,
13608        ) -> ValidatorExecutionTimeObservationFieldPathBuilder {
13609            self.path.push(ExecutionTimeObservation::VALIDATOR_OBSERVATIONS_FIELD.name);
13610            ValidatorExecutionTimeObservationFieldPathBuilder::new_with_base(self.path)
13611        }
13612    }
13613    impl ValidatorExecutionTimeObservation {
13614        pub const VALIDATOR_FIELD: &'static MessageField = &MessageField {
13615            name: "validator",
13616            json_name: "validator",
13617            number: 1i32,
13618            message_fields: None,
13619        };
13620        pub const DURATION_FIELD: &'static MessageField = &MessageField {
13621            name: "duration",
13622            json_name: "duration",
13623            number: 2i32,
13624            message_fields: None,
13625        };
13626    }
13627    impl MessageFields for ValidatorExecutionTimeObservation {
13628        const FIELDS: &'static [&'static MessageField] = &[
13629            Self::VALIDATOR_FIELD,
13630            Self::DURATION_FIELD,
13631        ];
13632    }
13633    impl ValidatorExecutionTimeObservation {
13634        pub fn path_builder() -> ValidatorExecutionTimeObservationFieldPathBuilder {
13635            ValidatorExecutionTimeObservationFieldPathBuilder::new()
13636        }
13637    }
13638    pub struct ValidatorExecutionTimeObservationFieldPathBuilder {
13639        path: Vec<&'static str>,
13640    }
13641    impl ValidatorExecutionTimeObservationFieldPathBuilder {
13642        #[allow(clippy::new_without_default)]
13643        pub fn new() -> Self {
13644            Self { path: Default::default() }
13645        }
13646        #[doc(hidden)]
13647        pub fn new_with_base(base: Vec<&'static str>) -> Self {
13648            Self { path: base }
13649        }
13650        pub fn finish(self) -> String {
13651            self.path.join(".")
13652        }
13653        pub fn validator(mut self) -> String {
13654            self.path.push(ValidatorExecutionTimeObservation::VALIDATOR_FIELD.name);
13655            self.finish()
13656        }
13657        pub fn duration(mut self) -> String {
13658            self.path.push(ValidatorExecutionTimeObservation::DURATION_FIELD.name);
13659            self.finish()
13660        }
13661    }
13662    impl ExecuteTransactionRequest {
13663        pub const TRANSACTION_FIELD: &'static MessageField = &MessageField {
13664            name: "transaction",
13665            json_name: "transaction",
13666            number: 1i32,
13667            message_fields: Some(Transaction::FIELDS),
13668        };
13669        pub const SIGNATURES_FIELD: &'static MessageField = &MessageField {
13670            name: "signatures",
13671            json_name: "signatures",
13672            number: 2i32,
13673            message_fields: Some(UserSignature::FIELDS),
13674        };
13675        pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
13676            name: "read_mask",
13677            json_name: "readMask",
13678            number: 3i32,
13679            message_fields: None,
13680        };
13681    }
13682    impl MessageFields for ExecuteTransactionRequest {
13683        const FIELDS: &'static [&'static MessageField] = &[
13684            Self::TRANSACTION_FIELD,
13685            Self::SIGNATURES_FIELD,
13686            Self::READ_MASK_FIELD,
13687        ];
13688    }
13689    impl ExecuteTransactionRequest {
13690        pub fn path_builder() -> ExecuteTransactionRequestFieldPathBuilder {
13691            ExecuteTransactionRequestFieldPathBuilder::new()
13692        }
13693    }
13694    pub struct ExecuteTransactionRequestFieldPathBuilder {
13695        path: Vec<&'static str>,
13696    }
13697    impl ExecuteTransactionRequestFieldPathBuilder {
13698        #[allow(clippy::new_without_default)]
13699        pub fn new() -> Self {
13700            Self { path: Default::default() }
13701        }
13702        #[doc(hidden)]
13703        pub fn new_with_base(base: Vec<&'static str>) -> Self {
13704            Self { path: base }
13705        }
13706        pub fn finish(self) -> String {
13707            self.path.join(".")
13708        }
13709        pub fn transaction(mut self) -> TransactionFieldPathBuilder {
13710            self.path.push(ExecuteTransactionRequest::TRANSACTION_FIELD.name);
13711            TransactionFieldPathBuilder::new_with_base(self.path)
13712        }
13713        pub fn signatures(mut self) -> UserSignatureFieldPathBuilder {
13714            self.path.push(ExecuteTransactionRequest::SIGNATURES_FIELD.name);
13715            UserSignatureFieldPathBuilder::new_with_base(self.path)
13716        }
13717        pub fn read_mask(mut self) -> String {
13718            self.path.push(ExecuteTransactionRequest::READ_MASK_FIELD.name);
13719            self.finish()
13720        }
13721    }
13722    impl ExecuteTransactionResponse {
13723        pub const TRANSACTION_FIELD: &'static MessageField = &MessageField {
13724            name: "transaction",
13725            json_name: "transaction",
13726            number: 1i32,
13727            message_fields: Some(ExecutedTransaction::FIELDS),
13728        };
13729    }
13730    impl MessageFields for ExecuteTransactionResponse {
13731        const FIELDS: &'static [&'static MessageField] = &[Self::TRANSACTION_FIELD];
13732    }
13733    impl ExecuteTransactionResponse {
13734        pub fn path_builder() -> ExecuteTransactionResponseFieldPathBuilder {
13735            ExecuteTransactionResponseFieldPathBuilder::new()
13736        }
13737    }
13738    pub struct ExecuteTransactionResponseFieldPathBuilder {
13739        path: Vec<&'static str>,
13740    }
13741    impl ExecuteTransactionResponseFieldPathBuilder {
13742        #[allow(clippy::new_without_default)]
13743        pub fn new() -> Self {
13744            Self { path: Default::default() }
13745        }
13746        #[doc(hidden)]
13747        pub fn new_with_base(base: Vec<&'static str>) -> Self {
13748            Self { path: base }
13749        }
13750        pub fn finish(self) -> String {
13751            self.path.join(".")
13752        }
13753        pub fn transaction(mut self) -> ExecutedTransactionFieldPathBuilder {
13754            self.path.push(ExecuteTransactionResponse::TRANSACTION_FIELD.name);
13755            ExecutedTransactionFieldPathBuilder::new_with_base(self.path)
13756        }
13757    }
13758    impl SimulateTransactionRequest {
13759        pub const TRANSACTION_FIELD: &'static MessageField = &MessageField {
13760            name: "transaction",
13761            json_name: "transaction",
13762            number: 1i32,
13763            message_fields: Some(Transaction::FIELDS),
13764        };
13765        pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
13766            name: "read_mask",
13767            json_name: "readMask",
13768            number: 2i32,
13769            message_fields: None,
13770        };
13771        pub const CHECKS_FIELD: &'static MessageField = &MessageField {
13772            name: "checks",
13773            json_name: "checks",
13774            number: 3i32,
13775            message_fields: None,
13776        };
13777        pub const DO_GAS_SELECTION_FIELD: &'static MessageField = &MessageField {
13778            name: "do_gas_selection",
13779            json_name: "doGasSelection",
13780            number: 4i32,
13781            message_fields: None,
13782        };
13783    }
13784    impl MessageFields for SimulateTransactionRequest {
13785        const FIELDS: &'static [&'static MessageField] = &[
13786            Self::TRANSACTION_FIELD,
13787            Self::READ_MASK_FIELD,
13788            Self::CHECKS_FIELD,
13789            Self::DO_GAS_SELECTION_FIELD,
13790        ];
13791    }
13792    impl SimulateTransactionRequest {
13793        pub fn path_builder() -> SimulateTransactionRequestFieldPathBuilder {
13794            SimulateTransactionRequestFieldPathBuilder::new()
13795        }
13796    }
13797    pub struct SimulateTransactionRequestFieldPathBuilder {
13798        path: Vec<&'static str>,
13799    }
13800    impl SimulateTransactionRequestFieldPathBuilder {
13801        #[allow(clippy::new_without_default)]
13802        pub fn new() -> Self {
13803            Self { path: Default::default() }
13804        }
13805        #[doc(hidden)]
13806        pub fn new_with_base(base: Vec<&'static str>) -> Self {
13807            Self { path: base }
13808        }
13809        pub fn finish(self) -> String {
13810            self.path.join(".")
13811        }
13812        pub fn transaction(mut self) -> TransactionFieldPathBuilder {
13813            self.path.push(SimulateTransactionRequest::TRANSACTION_FIELD.name);
13814            TransactionFieldPathBuilder::new_with_base(self.path)
13815        }
13816        pub fn read_mask(mut self) -> String {
13817            self.path.push(SimulateTransactionRequest::READ_MASK_FIELD.name);
13818            self.finish()
13819        }
13820        pub fn checks(mut self) -> String {
13821            self.path.push(SimulateTransactionRequest::CHECKS_FIELD.name);
13822            self.finish()
13823        }
13824        pub fn do_gas_selection(mut self) -> String {
13825            self.path.push(SimulateTransactionRequest::DO_GAS_SELECTION_FIELD.name);
13826            self.finish()
13827        }
13828    }
13829    impl SimulateTransactionResponse {
13830        pub const TRANSACTION_FIELD: &'static MessageField = &MessageField {
13831            name: "transaction",
13832            json_name: "transaction",
13833            number: 1i32,
13834            message_fields: Some(ExecutedTransaction::FIELDS),
13835        };
13836        pub const COMMAND_OUTPUTS_FIELD: &'static MessageField = &MessageField {
13837            name: "command_outputs",
13838            json_name: "commandOutputs",
13839            number: 2i32,
13840            message_fields: Some(CommandResult::FIELDS),
13841        };
13842        pub const SUGGESTED_GAS_PRICE_FIELD: &'static MessageField = &MessageField {
13843            name: "suggested_gas_price",
13844            json_name: "suggestedGasPrice",
13845            number: 3i32,
13846            message_fields: None,
13847        };
13848    }
13849    impl MessageFields for SimulateTransactionResponse {
13850        const FIELDS: &'static [&'static MessageField] = &[
13851            Self::TRANSACTION_FIELD,
13852            Self::COMMAND_OUTPUTS_FIELD,
13853            Self::SUGGESTED_GAS_PRICE_FIELD,
13854        ];
13855    }
13856    impl SimulateTransactionResponse {
13857        pub fn path_builder() -> SimulateTransactionResponseFieldPathBuilder {
13858            SimulateTransactionResponseFieldPathBuilder::new()
13859        }
13860    }
13861    pub struct SimulateTransactionResponseFieldPathBuilder {
13862        path: Vec<&'static str>,
13863    }
13864    impl SimulateTransactionResponseFieldPathBuilder {
13865        #[allow(clippy::new_without_default)]
13866        pub fn new() -> Self {
13867            Self { path: Default::default() }
13868        }
13869        #[doc(hidden)]
13870        pub fn new_with_base(base: Vec<&'static str>) -> Self {
13871            Self { path: base }
13872        }
13873        pub fn finish(self) -> String {
13874            self.path.join(".")
13875        }
13876        pub fn transaction(mut self) -> ExecutedTransactionFieldPathBuilder {
13877            self.path.push(SimulateTransactionResponse::TRANSACTION_FIELD.name);
13878            ExecutedTransactionFieldPathBuilder::new_with_base(self.path)
13879        }
13880        pub fn command_outputs(mut self) -> CommandResultFieldPathBuilder {
13881            self.path.push(SimulateTransactionResponse::COMMAND_OUTPUTS_FIELD.name);
13882            CommandResultFieldPathBuilder::new_with_base(self.path)
13883        }
13884        pub fn suggested_gas_price(mut self) -> String {
13885            self.path.push(SimulateTransactionResponse::SUGGESTED_GAS_PRICE_FIELD.name);
13886            self.finish()
13887        }
13888    }
13889    impl CommandResult {
13890        pub const RETURN_VALUES_FIELD: &'static MessageField = &MessageField {
13891            name: "return_values",
13892            json_name: "returnValues",
13893            number: 1i32,
13894            message_fields: Some(CommandOutput::FIELDS),
13895        };
13896        pub const MUTATED_BY_REF_FIELD: &'static MessageField = &MessageField {
13897            name: "mutated_by_ref",
13898            json_name: "mutatedByRef",
13899            number: 2i32,
13900            message_fields: Some(CommandOutput::FIELDS),
13901        };
13902    }
13903    impl MessageFields for CommandResult {
13904        const FIELDS: &'static [&'static MessageField] = &[
13905            Self::RETURN_VALUES_FIELD,
13906            Self::MUTATED_BY_REF_FIELD,
13907        ];
13908    }
13909    impl CommandResult {
13910        pub fn path_builder() -> CommandResultFieldPathBuilder {
13911            CommandResultFieldPathBuilder::new()
13912        }
13913    }
13914    pub struct CommandResultFieldPathBuilder {
13915        path: Vec<&'static str>,
13916    }
13917    impl CommandResultFieldPathBuilder {
13918        #[allow(clippy::new_without_default)]
13919        pub fn new() -> Self {
13920            Self { path: Default::default() }
13921        }
13922        #[doc(hidden)]
13923        pub fn new_with_base(base: Vec<&'static str>) -> Self {
13924            Self { path: base }
13925        }
13926        pub fn finish(self) -> String {
13927            self.path.join(".")
13928        }
13929        pub fn return_values(mut self) -> CommandOutputFieldPathBuilder {
13930            self.path.push(CommandResult::RETURN_VALUES_FIELD.name);
13931            CommandOutputFieldPathBuilder::new_with_base(self.path)
13932        }
13933        pub fn mutated_by_ref(mut self) -> CommandOutputFieldPathBuilder {
13934            self.path.push(CommandResult::MUTATED_BY_REF_FIELD.name);
13935            CommandOutputFieldPathBuilder::new_with_base(self.path)
13936        }
13937    }
13938    impl CommandOutput {
13939        pub const ARGUMENT_FIELD: &'static MessageField = &MessageField {
13940            name: "argument",
13941            json_name: "argument",
13942            number: 1i32,
13943            message_fields: Some(Argument::FIELDS),
13944        };
13945        pub const VALUE_FIELD: &'static MessageField = &MessageField {
13946            name: "value",
13947            json_name: "value",
13948            number: 2i32,
13949            message_fields: Some(Bcs::FIELDS),
13950        };
13951        pub const JSON_FIELD: &'static MessageField = &MessageField {
13952            name: "json",
13953            json_name: "json",
13954            number: 3i32,
13955            message_fields: None,
13956        };
13957    }
13958    impl MessageFields for CommandOutput {
13959        const FIELDS: &'static [&'static MessageField] = &[
13960            Self::ARGUMENT_FIELD,
13961            Self::VALUE_FIELD,
13962            Self::JSON_FIELD,
13963        ];
13964    }
13965    impl CommandOutput {
13966        pub fn path_builder() -> CommandOutputFieldPathBuilder {
13967            CommandOutputFieldPathBuilder::new()
13968        }
13969    }
13970    pub struct CommandOutputFieldPathBuilder {
13971        path: Vec<&'static str>,
13972    }
13973    impl CommandOutputFieldPathBuilder {
13974        #[allow(clippy::new_without_default)]
13975        pub fn new() -> Self {
13976            Self { path: Default::default() }
13977        }
13978        #[doc(hidden)]
13979        pub fn new_with_base(base: Vec<&'static str>) -> Self {
13980            Self { path: base }
13981        }
13982        pub fn finish(self) -> String {
13983            self.path.join(".")
13984        }
13985        pub fn argument(mut self) -> ArgumentFieldPathBuilder {
13986            self.path.push(CommandOutput::ARGUMENT_FIELD.name);
13987            ArgumentFieldPathBuilder::new_with_base(self.path)
13988        }
13989        pub fn value(mut self) -> BcsFieldPathBuilder {
13990            self.path.push(CommandOutput::VALUE_FIELD.name);
13991            BcsFieldPathBuilder::new_with_base(self.path)
13992        }
13993        pub fn json(mut self) -> String {
13994            self.path.push(CommandOutput::JSON_FIELD.name);
13995            self.finish()
13996        }
13997    }
13998}