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 }
1390 impl MessageFields for Epoch {
1391 const FIELDS: &'static [&'static MessageField] = &[
1392 Self::EPOCH_FIELD,
1393 Self::COMMITTEE_FIELD,
1394 Self::SYSTEM_STATE_FIELD,
1395 Self::FIRST_CHECKPOINT_FIELD,
1396 Self::LAST_CHECKPOINT_FIELD,
1397 Self::START_FIELD,
1398 Self::END_FIELD,
1399 Self::REFERENCE_GAS_PRICE_FIELD,
1400 Self::PROTOCOL_CONFIG_FIELD,
1401 ];
1402 }
1403 impl Epoch {
1404 pub fn path_builder() -> EpochFieldPathBuilder {
1405 EpochFieldPathBuilder::new()
1406 }
1407 }
1408 pub struct EpochFieldPathBuilder {
1409 path: Vec<&'static str>,
1410 }
1411 impl EpochFieldPathBuilder {
1412 #[allow(clippy::new_without_default)]
1413 pub fn new() -> Self {
1414 Self { path: Default::default() }
1415 }
1416 #[doc(hidden)]
1417 pub fn new_with_base(base: Vec<&'static str>) -> Self {
1418 Self { path: base }
1419 }
1420 pub fn finish(self) -> String {
1421 self.path.join(".")
1422 }
1423 pub fn epoch(mut self) -> String {
1424 self.path.push(Epoch::EPOCH_FIELD.name);
1425 self.finish()
1426 }
1427 pub fn committee(mut self) -> ValidatorCommitteeFieldPathBuilder {
1428 self.path.push(Epoch::COMMITTEE_FIELD.name);
1429 ValidatorCommitteeFieldPathBuilder::new_with_base(self.path)
1430 }
1431 pub fn system_state(mut self) -> SystemStateFieldPathBuilder {
1432 self.path.push(Epoch::SYSTEM_STATE_FIELD.name);
1433 SystemStateFieldPathBuilder::new_with_base(self.path)
1434 }
1435 pub fn first_checkpoint(mut self) -> String {
1436 self.path.push(Epoch::FIRST_CHECKPOINT_FIELD.name);
1437 self.finish()
1438 }
1439 pub fn last_checkpoint(mut self) -> String {
1440 self.path.push(Epoch::LAST_CHECKPOINT_FIELD.name);
1441 self.finish()
1442 }
1443 pub fn start(mut self) -> String {
1444 self.path.push(Epoch::START_FIELD.name);
1445 self.finish()
1446 }
1447 pub fn end(mut self) -> String {
1448 self.path.push(Epoch::END_FIELD.name);
1449 self.finish()
1450 }
1451 pub fn reference_gas_price(mut self) -> String {
1452 self.path.push(Epoch::REFERENCE_GAS_PRICE_FIELD.name);
1453 self.finish()
1454 }
1455 pub fn protocol_config(mut self) -> ProtocolConfigFieldPathBuilder {
1456 self.path.push(Epoch::PROTOCOL_CONFIG_FIELD.name);
1457 ProtocolConfigFieldPathBuilder::new_with_base(self.path)
1458 }
1459 }
1460 impl TransactionEvents {
1461 pub const BCS_FIELD: &'static MessageField = &MessageField {
1462 name: "bcs",
1463 json_name: "bcs",
1464 number: 1i32,
1465 message_fields: Some(Bcs::FIELDS),
1466 };
1467 pub const DIGEST_FIELD: &'static MessageField = &MessageField {
1468 name: "digest",
1469 json_name: "digest",
1470 number: 2i32,
1471 message_fields: None,
1472 };
1473 pub const EVENTS_FIELD: &'static MessageField = &MessageField {
1474 name: "events",
1475 json_name: "events",
1476 number: 3i32,
1477 message_fields: Some(Event::FIELDS),
1478 };
1479 }
1480 impl MessageFields for TransactionEvents {
1481 const FIELDS: &'static [&'static MessageField] = &[
1482 Self::BCS_FIELD,
1483 Self::DIGEST_FIELD,
1484 Self::EVENTS_FIELD,
1485 ];
1486 }
1487 impl TransactionEvents {
1488 pub fn path_builder() -> TransactionEventsFieldPathBuilder {
1489 TransactionEventsFieldPathBuilder::new()
1490 }
1491 }
1492 pub struct TransactionEventsFieldPathBuilder {
1493 path: Vec<&'static str>,
1494 }
1495 impl TransactionEventsFieldPathBuilder {
1496 #[allow(clippy::new_without_default)]
1497 pub fn new() -> Self {
1498 Self { path: Default::default() }
1499 }
1500 #[doc(hidden)]
1501 pub fn new_with_base(base: Vec<&'static str>) -> Self {
1502 Self { path: base }
1503 }
1504 pub fn finish(self) -> String {
1505 self.path.join(".")
1506 }
1507 pub fn bcs(mut self) -> BcsFieldPathBuilder {
1508 self.path.push(TransactionEvents::BCS_FIELD.name);
1509 BcsFieldPathBuilder::new_with_base(self.path)
1510 }
1511 pub fn digest(mut self) -> String {
1512 self.path.push(TransactionEvents::DIGEST_FIELD.name);
1513 self.finish()
1514 }
1515 pub fn events(mut self) -> EventFieldPathBuilder {
1516 self.path.push(TransactionEvents::EVENTS_FIELD.name);
1517 EventFieldPathBuilder::new_with_base(self.path)
1518 }
1519 }
1520 impl Event {
1521 pub const PACKAGE_ID_FIELD: &'static MessageField = &MessageField {
1522 name: "package_id",
1523 json_name: "packageId",
1524 number: 1i32,
1525 message_fields: None,
1526 };
1527 pub const MODULE_FIELD: &'static MessageField = &MessageField {
1528 name: "module",
1529 json_name: "module",
1530 number: 2i32,
1531 message_fields: None,
1532 };
1533 pub const SENDER_FIELD: &'static MessageField = &MessageField {
1534 name: "sender",
1535 json_name: "sender",
1536 number: 3i32,
1537 message_fields: None,
1538 };
1539 pub const EVENT_TYPE_FIELD: &'static MessageField = &MessageField {
1540 name: "event_type",
1541 json_name: "eventType",
1542 number: 4i32,
1543 message_fields: None,
1544 };
1545 pub const CONTENTS_FIELD: &'static MessageField = &MessageField {
1546 name: "contents",
1547 json_name: "contents",
1548 number: 5i32,
1549 message_fields: Some(Bcs::FIELDS),
1550 };
1551 pub const JSON_FIELD: &'static MessageField = &MessageField {
1552 name: "json",
1553 json_name: "json",
1554 number: 6i32,
1555 message_fields: None,
1556 };
1557 pub const CHECKPOINT_FIELD: &'static MessageField = &MessageField {
1558 name: "checkpoint",
1559 json_name: "checkpoint",
1560 number: 7i32,
1561 message_fields: None,
1562 };
1563 pub const TRANSACTION_DIGEST_FIELD: &'static MessageField = &MessageField {
1564 name: "transaction_digest",
1565 json_name: "transactionDigest",
1566 number: 8i32,
1567 message_fields: None,
1568 };
1569 pub const TRANSACTION_INDEX_FIELD: &'static MessageField = &MessageField {
1570 name: "transaction_index",
1571 json_name: "transactionIndex",
1572 number: 9i32,
1573 message_fields: None,
1574 };
1575 pub const EVENT_INDEX_FIELD: &'static MessageField = &MessageField {
1576 name: "event_index",
1577 json_name: "eventIndex",
1578 number: 10i32,
1579 message_fields: None,
1580 };
1581 }
1582 impl MessageFields for Event {
1583 const FIELDS: &'static [&'static MessageField] = &[
1584 Self::PACKAGE_ID_FIELD,
1585 Self::MODULE_FIELD,
1586 Self::SENDER_FIELD,
1587 Self::EVENT_TYPE_FIELD,
1588 Self::CONTENTS_FIELD,
1589 Self::JSON_FIELD,
1590 Self::CHECKPOINT_FIELD,
1591 Self::TRANSACTION_DIGEST_FIELD,
1592 Self::TRANSACTION_INDEX_FIELD,
1593 Self::EVENT_INDEX_FIELD,
1594 ];
1595 }
1596 impl Event {
1597 pub fn path_builder() -> EventFieldPathBuilder {
1598 EventFieldPathBuilder::new()
1599 }
1600 }
1601 pub struct EventFieldPathBuilder {
1602 path: Vec<&'static str>,
1603 }
1604 impl EventFieldPathBuilder {
1605 #[allow(clippy::new_without_default)]
1606 pub fn new() -> Self {
1607 Self { path: Default::default() }
1608 }
1609 #[doc(hidden)]
1610 pub fn new_with_base(base: Vec<&'static str>) -> Self {
1611 Self { path: base }
1612 }
1613 pub fn finish(self) -> String {
1614 self.path.join(".")
1615 }
1616 pub fn package_id(mut self) -> String {
1617 self.path.push(Event::PACKAGE_ID_FIELD.name);
1618 self.finish()
1619 }
1620 pub fn module(mut self) -> String {
1621 self.path.push(Event::MODULE_FIELD.name);
1622 self.finish()
1623 }
1624 pub fn sender(mut self) -> String {
1625 self.path.push(Event::SENDER_FIELD.name);
1626 self.finish()
1627 }
1628 pub fn event_type(mut self) -> String {
1629 self.path.push(Event::EVENT_TYPE_FIELD.name);
1630 self.finish()
1631 }
1632 pub fn contents(mut self) -> BcsFieldPathBuilder {
1633 self.path.push(Event::CONTENTS_FIELD.name);
1634 BcsFieldPathBuilder::new_with_base(self.path)
1635 }
1636 pub fn json(mut self) -> String {
1637 self.path.push(Event::JSON_FIELD.name);
1638 self.finish()
1639 }
1640 pub fn checkpoint(mut self) -> String {
1641 self.path.push(Event::CHECKPOINT_FIELD.name);
1642 self.finish()
1643 }
1644 pub fn transaction_digest(mut self) -> String {
1645 self.path.push(Event::TRANSACTION_DIGEST_FIELD.name);
1646 self.finish()
1647 }
1648 pub fn transaction_index(mut self) -> String {
1649 self.path.push(Event::TRANSACTION_INDEX_FIELD.name);
1650 self.finish()
1651 }
1652 pub fn event_index(mut self) -> String {
1653 self.path.push(Event::EVENT_INDEX_FIELD.name);
1654 self.finish()
1655 }
1656 }
1657 impl ExecutedTransaction {
1658 pub const DIGEST_FIELD: &'static MessageField = &MessageField {
1659 name: "digest",
1660 json_name: "digest",
1661 number: 1i32,
1662 message_fields: None,
1663 };
1664 pub const TRANSACTION_FIELD: &'static MessageField = &MessageField {
1665 name: "transaction",
1666 json_name: "transaction",
1667 number: 2i32,
1668 message_fields: Some(Transaction::FIELDS),
1669 };
1670 pub const SIGNATURES_FIELD: &'static MessageField = &MessageField {
1671 name: "signatures",
1672 json_name: "signatures",
1673 number: 3i32,
1674 message_fields: Some(UserSignature::FIELDS),
1675 };
1676 pub const EFFECTS_FIELD: &'static MessageField = &MessageField {
1677 name: "effects",
1678 json_name: "effects",
1679 number: 4i32,
1680 message_fields: Some(TransactionEffects::FIELDS),
1681 };
1682 pub const EVENTS_FIELD: &'static MessageField = &MessageField {
1683 name: "events",
1684 json_name: "events",
1685 number: 5i32,
1686 message_fields: Some(TransactionEvents::FIELDS),
1687 };
1688 pub const CHECKPOINT_FIELD: &'static MessageField = &MessageField {
1689 name: "checkpoint",
1690 json_name: "checkpoint",
1691 number: 6i32,
1692 message_fields: None,
1693 };
1694 pub const TIMESTAMP_FIELD: &'static MessageField = &MessageField {
1695 name: "timestamp",
1696 json_name: "timestamp",
1697 number: 7i32,
1698 message_fields: None,
1699 };
1700 pub const BALANCE_CHANGES_FIELD: &'static MessageField = &MessageField {
1701 name: "balance_changes",
1702 json_name: "balanceChanges",
1703 number: 8i32,
1704 message_fields: Some(BalanceChange::FIELDS),
1705 };
1706 pub const OBJECTS_FIELD: &'static MessageField = &MessageField {
1707 name: "objects",
1708 json_name: "objects",
1709 number: 9i32,
1710 message_fields: Some(ObjectSet::FIELDS),
1711 };
1712 pub const TRANSACTION_INDEX_FIELD: &'static MessageField = &MessageField {
1713 name: "transaction_index",
1714 json_name: "transactionIndex",
1715 number: 10i32,
1716 message_fields: None,
1717 };
1718 }
1719 impl MessageFields for ExecutedTransaction {
1720 const FIELDS: &'static [&'static MessageField] = &[
1721 Self::DIGEST_FIELD,
1722 Self::TRANSACTION_FIELD,
1723 Self::SIGNATURES_FIELD,
1724 Self::EFFECTS_FIELD,
1725 Self::EVENTS_FIELD,
1726 Self::CHECKPOINT_FIELD,
1727 Self::TIMESTAMP_FIELD,
1728 Self::BALANCE_CHANGES_FIELD,
1729 Self::OBJECTS_FIELD,
1730 Self::TRANSACTION_INDEX_FIELD,
1731 ];
1732 }
1733 impl ExecutedTransaction {
1734 pub fn path_builder() -> ExecutedTransactionFieldPathBuilder {
1735 ExecutedTransactionFieldPathBuilder::new()
1736 }
1737 }
1738 pub struct ExecutedTransactionFieldPathBuilder {
1739 path: Vec<&'static str>,
1740 }
1741 impl ExecutedTransactionFieldPathBuilder {
1742 #[allow(clippy::new_without_default)]
1743 pub fn new() -> Self {
1744 Self { path: Default::default() }
1745 }
1746 #[doc(hidden)]
1747 pub fn new_with_base(base: Vec<&'static str>) -> Self {
1748 Self { path: base }
1749 }
1750 pub fn finish(self) -> String {
1751 self.path.join(".")
1752 }
1753 pub fn digest(mut self) -> String {
1754 self.path.push(ExecutedTransaction::DIGEST_FIELD.name);
1755 self.finish()
1756 }
1757 pub fn transaction(mut self) -> TransactionFieldPathBuilder {
1758 self.path.push(ExecutedTransaction::TRANSACTION_FIELD.name);
1759 TransactionFieldPathBuilder::new_with_base(self.path)
1760 }
1761 pub fn signatures(mut self) -> UserSignatureFieldPathBuilder {
1762 self.path.push(ExecutedTransaction::SIGNATURES_FIELD.name);
1763 UserSignatureFieldPathBuilder::new_with_base(self.path)
1764 }
1765 pub fn effects(mut self) -> TransactionEffectsFieldPathBuilder {
1766 self.path.push(ExecutedTransaction::EFFECTS_FIELD.name);
1767 TransactionEffectsFieldPathBuilder::new_with_base(self.path)
1768 }
1769 pub fn events(mut self) -> TransactionEventsFieldPathBuilder {
1770 self.path.push(ExecutedTransaction::EVENTS_FIELD.name);
1771 TransactionEventsFieldPathBuilder::new_with_base(self.path)
1772 }
1773 pub fn checkpoint(mut self) -> String {
1774 self.path.push(ExecutedTransaction::CHECKPOINT_FIELD.name);
1775 self.finish()
1776 }
1777 pub fn timestamp(mut self) -> String {
1778 self.path.push(ExecutedTransaction::TIMESTAMP_FIELD.name);
1779 self.finish()
1780 }
1781 pub fn balance_changes(mut self) -> BalanceChangeFieldPathBuilder {
1782 self.path.push(ExecutedTransaction::BALANCE_CHANGES_FIELD.name);
1783 BalanceChangeFieldPathBuilder::new_with_base(self.path)
1784 }
1785 pub fn objects(mut self) -> ObjectSetFieldPathBuilder {
1786 self.path.push(ExecutedTransaction::OBJECTS_FIELD.name);
1787 ObjectSetFieldPathBuilder::new_with_base(self.path)
1788 }
1789 pub fn transaction_index(mut self) -> String {
1790 self.path.push(ExecutedTransaction::TRANSACTION_INDEX_FIELD.name);
1791 self.finish()
1792 }
1793 }
1794 impl ExecutionStatus {
1795 pub const SUCCESS_FIELD: &'static MessageField = &MessageField {
1796 name: "success",
1797 json_name: "success",
1798 number: 1i32,
1799 message_fields: None,
1800 };
1801 pub const ERROR_FIELD: &'static MessageField = &MessageField {
1802 name: "error",
1803 json_name: "error",
1804 number: 2i32,
1805 message_fields: Some(ExecutionError::FIELDS),
1806 };
1807 }
1808 impl MessageFields for ExecutionStatus {
1809 const FIELDS: &'static [&'static MessageField] = &[
1810 Self::SUCCESS_FIELD,
1811 Self::ERROR_FIELD,
1812 ];
1813 }
1814 impl ExecutionStatus {
1815 pub fn path_builder() -> ExecutionStatusFieldPathBuilder {
1816 ExecutionStatusFieldPathBuilder::new()
1817 }
1818 }
1819 pub struct ExecutionStatusFieldPathBuilder {
1820 path: Vec<&'static str>,
1821 }
1822 impl ExecutionStatusFieldPathBuilder {
1823 #[allow(clippy::new_without_default)]
1824 pub fn new() -> Self {
1825 Self { path: Default::default() }
1826 }
1827 #[doc(hidden)]
1828 pub fn new_with_base(base: Vec<&'static str>) -> Self {
1829 Self { path: base }
1830 }
1831 pub fn finish(self) -> String {
1832 self.path.join(".")
1833 }
1834 pub fn success(mut self) -> String {
1835 self.path.push(ExecutionStatus::SUCCESS_FIELD.name);
1836 self.finish()
1837 }
1838 pub fn error(mut self) -> ExecutionErrorFieldPathBuilder {
1839 self.path.push(ExecutionStatus::ERROR_FIELD.name);
1840 ExecutionErrorFieldPathBuilder::new_with_base(self.path)
1841 }
1842 }
1843 impl ExecutionError {
1844 pub const DESCRIPTION_FIELD: &'static MessageField = &MessageField {
1845 name: "description",
1846 json_name: "description",
1847 number: 1i32,
1848 message_fields: None,
1849 };
1850 pub const COMMAND_FIELD: &'static MessageField = &MessageField {
1851 name: "command",
1852 json_name: "command",
1853 number: 2i32,
1854 message_fields: None,
1855 };
1856 pub const KIND_FIELD: &'static MessageField = &MessageField {
1857 name: "kind",
1858 json_name: "kind",
1859 number: 3i32,
1860 message_fields: None,
1861 };
1862 pub const ABORT_FIELD: &'static MessageField = &MessageField {
1863 name: "abort",
1864 json_name: "abort",
1865 number: 4i32,
1866 message_fields: Some(MoveAbort::FIELDS),
1867 };
1868 pub const SIZE_ERROR_FIELD: &'static MessageField = &MessageField {
1869 name: "size_error",
1870 json_name: "sizeError",
1871 number: 5i32,
1872 message_fields: Some(SizeError::FIELDS),
1873 };
1874 pub const COMMAND_ARGUMENT_ERROR_FIELD: &'static MessageField = &MessageField {
1875 name: "command_argument_error",
1876 json_name: "commandArgumentError",
1877 number: 6i32,
1878 message_fields: Some(CommandArgumentError::FIELDS),
1879 };
1880 pub const TYPE_ARGUMENT_ERROR_FIELD: &'static MessageField = &MessageField {
1881 name: "type_argument_error",
1882 json_name: "typeArgumentError",
1883 number: 7i32,
1884 message_fields: Some(TypeArgumentError::FIELDS),
1885 };
1886 pub const PACKAGE_UPGRADE_ERROR_FIELD: &'static MessageField = &MessageField {
1887 name: "package_upgrade_error",
1888 json_name: "packageUpgradeError",
1889 number: 8i32,
1890 message_fields: Some(PackageUpgradeError::FIELDS),
1891 };
1892 pub const INDEX_ERROR_FIELD: &'static MessageField = &MessageField {
1893 name: "index_error",
1894 json_name: "indexError",
1895 number: 9i32,
1896 message_fields: Some(IndexError::FIELDS),
1897 };
1898 pub const OBJECT_ID_FIELD: &'static MessageField = &MessageField {
1899 name: "object_id",
1900 json_name: "objectId",
1901 number: 10i32,
1902 message_fields: None,
1903 };
1904 pub const COIN_DENY_LIST_ERROR_FIELD: &'static MessageField = &MessageField {
1905 name: "coin_deny_list_error",
1906 json_name: "coinDenyListError",
1907 number: 11i32,
1908 message_fields: Some(CoinDenyListError::FIELDS),
1909 };
1910 pub const CONGESTED_OBJECTS_FIELD: &'static MessageField = &MessageField {
1911 name: "congested_objects",
1912 json_name: "congestedObjects",
1913 number: 12i32,
1914 message_fields: Some(CongestedObjects::FIELDS),
1915 };
1916 }
1917 impl MessageFields for ExecutionError {
1918 const FIELDS: &'static [&'static MessageField] = &[
1919 Self::DESCRIPTION_FIELD,
1920 Self::COMMAND_FIELD,
1921 Self::KIND_FIELD,
1922 Self::ABORT_FIELD,
1923 Self::SIZE_ERROR_FIELD,
1924 Self::COMMAND_ARGUMENT_ERROR_FIELD,
1925 Self::TYPE_ARGUMENT_ERROR_FIELD,
1926 Self::PACKAGE_UPGRADE_ERROR_FIELD,
1927 Self::INDEX_ERROR_FIELD,
1928 Self::OBJECT_ID_FIELD,
1929 Self::COIN_DENY_LIST_ERROR_FIELD,
1930 Self::CONGESTED_OBJECTS_FIELD,
1931 ];
1932 }
1933 impl ExecutionError {
1934 pub fn path_builder() -> ExecutionErrorFieldPathBuilder {
1935 ExecutionErrorFieldPathBuilder::new()
1936 }
1937 }
1938 pub struct ExecutionErrorFieldPathBuilder {
1939 path: Vec<&'static str>,
1940 }
1941 impl ExecutionErrorFieldPathBuilder {
1942 #[allow(clippy::new_without_default)]
1943 pub fn new() -> Self {
1944 Self { path: Default::default() }
1945 }
1946 #[doc(hidden)]
1947 pub fn new_with_base(base: Vec<&'static str>) -> Self {
1948 Self { path: base }
1949 }
1950 pub fn finish(self) -> String {
1951 self.path.join(".")
1952 }
1953 pub fn description(mut self) -> String {
1954 self.path.push(ExecutionError::DESCRIPTION_FIELD.name);
1955 self.finish()
1956 }
1957 pub fn command(mut self) -> String {
1958 self.path.push(ExecutionError::COMMAND_FIELD.name);
1959 self.finish()
1960 }
1961 pub fn kind(mut self) -> String {
1962 self.path.push(ExecutionError::KIND_FIELD.name);
1963 self.finish()
1964 }
1965 pub fn abort(mut self) -> MoveAbortFieldPathBuilder {
1966 self.path.push(ExecutionError::ABORT_FIELD.name);
1967 MoveAbortFieldPathBuilder::new_with_base(self.path)
1968 }
1969 pub fn size_error(mut self) -> SizeErrorFieldPathBuilder {
1970 self.path.push(ExecutionError::SIZE_ERROR_FIELD.name);
1971 SizeErrorFieldPathBuilder::new_with_base(self.path)
1972 }
1973 pub fn command_argument_error(mut self) -> CommandArgumentErrorFieldPathBuilder {
1974 self.path.push(ExecutionError::COMMAND_ARGUMENT_ERROR_FIELD.name);
1975 CommandArgumentErrorFieldPathBuilder::new_with_base(self.path)
1976 }
1977 pub fn type_argument_error(mut self) -> TypeArgumentErrorFieldPathBuilder {
1978 self.path.push(ExecutionError::TYPE_ARGUMENT_ERROR_FIELD.name);
1979 TypeArgumentErrorFieldPathBuilder::new_with_base(self.path)
1980 }
1981 pub fn package_upgrade_error(mut self) -> PackageUpgradeErrorFieldPathBuilder {
1982 self.path.push(ExecutionError::PACKAGE_UPGRADE_ERROR_FIELD.name);
1983 PackageUpgradeErrorFieldPathBuilder::new_with_base(self.path)
1984 }
1985 pub fn index_error(mut self) -> IndexErrorFieldPathBuilder {
1986 self.path.push(ExecutionError::INDEX_ERROR_FIELD.name);
1987 IndexErrorFieldPathBuilder::new_with_base(self.path)
1988 }
1989 pub fn object_id(mut self) -> String {
1990 self.path.push(ExecutionError::OBJECT_ID_FIELD.name);
1991 self.finish()
1992 }
1993 pub fn coin_deny_list_error(mut self) -> CoinDenyListErrorFieldPathBuilder {
1994 self.path.push(ExecutionError::COIN_DENY_LIST_ERROR_FIELD.name);
1995 CoinDenyListErrorFieldPathBuilder::new_with_base(self.path)
1996 }
1997 pub fn congested_objects(mut self) -> CongestedObjectsFieldPathBuilder {
1998 self.path.push(ExecutionError::CONGESTED_OBJECTS_FIELD.name);
1999 CongestedObjectsFieldPathBuilder::new_with_base(self.path)
2000 }
2001 }
2002 impl MoveAbort {
2003 pub const ABORT_CODE_FIELD: &'static MessageField = &MessageField {
2004 name: "abort_code",
2005 json_name: "abortCode",
2006 number: 1i32,
2007 message_fields: None,
2008 };
2009 pub const LOCATION_FIELD: &'static MessageField = &MessageField {
2010 name: "location",
2011 json_name: "location",
2012 number: 2i32,
2013 message_fields: Some(MoveLocation::FIELDS),
2014 };
2015 pub const CLEVER_ERROR_FIELD: &'static MessageField = &MessageField {
2016 name: "clever_error",
2017 json_name: "cleverError",
2018 number: 3i32,
2019 message_fields: Some(CleverError::FIELDS),
2020 };
2021 }
2022 impl MessageFields for MoveAbort {
2023 const FIELDS: &'static [&'static MessageField] = &[
2024 Self::ABORT_CODE_FIELD,
2025 Self::LOCATION_FIELD,
2026 Self::CLEVER_ERROR_FIELD,
2027 ];
2028 }
2029 impl MoveAbort {
2030 pub fn path_builder() -> MoveAbortFieldPathBuilder {
2031 MoveAbortFieldPathBuilder::new()
2032 }
2033 }
2034 pub struct MoveAbortFieldPathBuilder {
2035 path: Vec<&'static str>,
2036 }
2037 impl MoveAbortFieldPathBuilder {
2038 #[allow(clippy::new_without_default)]
2039 pub fn new() -> Self {
2040 Self { path: Default::default() }
2041 }
2042 #[doc(hidden)]
2043 pub fn new_with_base(base: Vec<&'static str>) -> Self {
2044 Self { path: base }
2045 }
2046 pub fn finish(self) -> String {
2047 self.path.join(".")
2048 }
2049 pub fn abort_code(mut self) -> String {
2050 self.path.push(MoveAbort::ABORT_CODE_FIELD.name);
2051 self.finish()
2052 }
2053 pub fn location(mut self) -> MoveLocationFieldPathBuilder {
2054 self.path.push(MoveAbort::LOCATION_FIELD.name);
2055 MoveLocationFieldPathBuilder::new_with_base(self.path)
2056 }
2057 pub fn clever_error(mut self) -> CleverErrorFieldPathBuilder {
2058 self.path.push(MoveAbort::CLEVER_ERROR_FIELD.name);
2059 CleverErrorFieldPathBuilder::new_with_base(self.path)
2060 }
2061 }
2062 impl MoveLocation {
2063 pub const PACKAGE_FIELD: &'static MessageField = &MessageField {
2064 name: "package",
2065 json_name: "package",
2066 number: 1i32,
2067 message_fields: None,
2068 };
2069 pub const MODULE_FIELD: &'static MessageField = &MessageField {
2070 name: "module",
2071 json_name: "module",
2072 number: 2i32,
2073 message_fields: None,
2074 };
2075 pub const FUNCTION_FIELD: &'static MessageField = &MessageField {
2076 name: "function",
2077 json_name: "function",
2078 number: 3i32,
2079 message_fields: None,
2080 };
2081 pub const INSTRUCTION_FIELD: &'static MessageField = &MessageField {
2082 name: "instruction",
2083 json_name: "instruction",
2084 number: 4i32,
2085 message_fields: None,
2086 };
2087 pub const FUNCTION_NAME_FIELD: &'static MessageField = &MessageField {
2088 name: "function_name",
2089 json_name: "functionName",
2090 number: 5i32,
2091 message_fields: None,
2092 };
2093 }
2094 impl MessageFields for MoveLocation {
2095 const FIELDS: &'static [&'static MessageField] = &[
2096 Self::PACKAGE_FIELD,
2097 Self::MODULE_FIELD,
2098 Self::FUNCTION_FIELD,
2099 Self::INSTRUCTION_FIELD,
2100 Self::FUNCTION_NAME_FIELD,
2101 ];
2102 }
2103 impl MoveLocation {
2104 pub fn path_builder() -> MoveLocationFieldPathBuilder {
2105 MoveLocationFieldPathBuilder::new()
2106 }
2107 }
2108 pub struct MoveLocationFieldPathBuilder {
2109 path: Vec<&'static str>,
2110 }
2111 impl MoveLocationFieldPathBuilder {
2112 #[allow(clippy::new_without_default)]
2113 pub fn new() -> Self {
2114 Self { path: Default::default() }
2115 }
2116 #[doc(hidden)]
2117 pub fn new_with_base(base: Vec<&'static str>) -> Self {
2118 Self { path: base }
2119 }
2120 pub fn finish(self) -> String {
2121 self.path.join(".")
2122 }
2123 pub fn package(mut self) -> String {
2124 self.path.push(MoveLocation::PACKAGE_FIELD.name);
2125 self.finish()
2126 }
2127 pub fn module(mut self) -> String {
2128 self.path.push(MoveLocation::MODULE_FIELD.name);
2129 self.finish()
2130 }
2131 pub fn function(mut self) -> String {
2132 self.path.push(MoveLocation::FUNCTION_FIELD.name);
2133 self.finish()
2134 }
2135 pub fn instruction(mut self) -> String {
2136 self.path.push(MoveLocation::INSTRUCTION_FIELD.name);
2137 self.finish()
2138 }
2139 pub fn function_name(mut self) -> String {
2140 self.path.push(MoveLocation::FUNCTION_NAME_FIELD.name);
2141 self.finish()
2142 }
2143 }
2144 impl CleverError {
2145 pub const ERROR_CODE_FIELD: &'static MessageField = &MessageField {
2146 name: "error_code",
2147 json_name: "errorCode",
2148 number: 1i32,
2149 message_fields: None,
2150 };
2151 pub const LINE_NUMBER_FIELD: &'static MessageField = &MessageField {
2152 name: "line_number",
2153 json_name: "lineNumber",
2154 number: 2i32,
2155 message_fields: None,
2156 };
2157 pub const CONSTANT_NAME_FIELD: &'static MessageField = &MessageField {
2158 name: "constant_name",
2159 json_name: "constantName",
2160 number: 3i32,
2161 message_fields: None,
2162 };
2163 pub const CONSTANT_TYPE_FIELD: &'static MessageField = &MessageField {
2164 name: "constant_type",
2165 json_name: "constantType",
2166 number: 4i32,
2167 message_fields: None,
2168 };
2169 pub const RENDERED_FIELD: &'static MessageField = &MessageField {
2170 name: "rendered",
2171 json_name: "rendered",
2172 number: 5i32,
2173 message_fields: None,
2174 };
2175 pub const RAW_FIELD: &'static MessageField = &MessageField {
2176 name: "raw",
2177 json_name: "raw",
2178 number: 6i32,
2179 message_fields: None,
2180 };
2181 }
2182 impl MessageFields for CleverError {
2183 const FIELDS: &'static [&'static MessageField] = &[
2184 Self::ERROR_CODE_FIELD,
2185 Self::LINE_NUMBER_FIELD,
2186 Self::CONSTANT_NAME_FIELD,
2187 Self::CONSTANT_TYPE_FIELD,
2188 Self::RENDERED_FIELD,
2189 Self::RAW_FIELD,
2190 ];
2191 }
2192 impl CleverError {
2193 pub fn path_builder() -> CleverErrorFieldPathBuilder {
2194 CleverErrorFieldPathBuilder::new()
2195 }
2196 }
2197 pub struct CleverErrorFieldPathBuilder {
2198 path: Vec<&'static str>,
2199 }
2200 impl CleverErrorFieldPathBuilder {
2201 #[allow(clippy::new_without_default)]
2202 pub fn new() -> Self {
2203 Self { path: Default::default() }
2204 }
2205 #[doc(hidden)]
2206 pub fn new_with_base(base: Vec<&'static str>) -> Self {
2207 Self { path: base }
2208 }
2209 pub fn finish(self) -> String {
2210 self.path.join(".")
2211 }
2212 pub fn error_code(mut self) -> String {
2213 self.path.push(CleverError::ERROR_CODE_FIELD.name);
2214 self.finish()
2215 }
2216 pub fn line_number(mut self) -> String {
2217 self.path.push(CleverError::LINE_NUMBER_FIELD.name);
2218 self.finish()
2219 }
2220 pub fn constant_name(mut self) -> String {
2221 self.path.push(CleverError::CONSTANT_NAME_FIELD.name);
2222 self.finish()
2223 }
2224 pub fn constant_type(mut self) -> String {
2225 self.path.push(CleverError::CONSTANT_TYPE_FIELD.name);
2226 self.finish()
2227 }
2228 pub fn rendered(mut self) -> String {
2229 self.path.push(CleverError::RENDERED_FIELD.name);
2230 self.finish()
2231 }
2232 pub fn raw(mut self) -> String {
2233 self.path.push(CleverError::RAW_FIELD.name);
2234 self.finish()
2235 }
2236 }
2237 impl SizeError {
2238 pub const SIZE_FIELD: &'static MessageField = &MessageField {
2239 name: "size",
2240 json_name: "size",
2241 number: 1i32,
2242 message_fields: None,
2243 };
2244 pub const MAX_SIZE_FIELD: &'static MessageField = &MessageField {
2245 name: "max_size",
2246 json_name: "maxSize",
2247 number: 2i32,
2248 message_fields: None,
2249 };
2250 }
2251 impl MessageFields for SizeError {
2252 const FIELDS: &'static [&'static MessageField] = &[
2253 Self::SIZE_FIELD,
2254 Self::MAX_SIZE_FIELD,
2255 ];
2256 }
2257 impl SizeError {
2258 pub fn path_builder() -> SizeErrorFieldPathBuilder {
2259 SizeErrorFieldPathBuilder::new()
2260 }
2261 }
2262 pub struct SizeErrorFieldPathBuilder {
2263 path: Vec<&'static str>,
2264 }
2265 impl SizeErrorFieldPathBuilder {
2266 #[allow(clippy::new_without_default)]
2267 pub fn new() -> Self {
2268 Self { path: Default::default() }
2269 }
2270 #[doc(hidden)]
2271 pub fn new_with_base(base: Vec<&'static str>) -> Self {
2272 Self { path: base }
2273 }
2274 pub fn finish(self) -> String {
2275 self.path.join(".")
2276 }
2277 pub fn size(mut self) -> String {
2278 self.path.push(SizeError::SIZE_FIELD.name);
2279 self.finish()
2280 }
2281 pub fn max_size(mut self) -> String {
2282 self.path.push(SizeError::MAX_SIZE_FIELD.name);
2283 self.finish()
2284 }
2285 }
2286 impl IndexError {
2287 pub const INDEX_FIELD: &'static MessageField = &MessageField {
2288 name: "index",
2289 json_name: "index",
2290 number: 1i32,
2291 message_fields: None,
2292 };
2293 pub const SUBRESULT_FIELD: &'static MessageField = &MessageField {
2294 name: "subresult",
2295 json_name: "subresult",
2296 number: 2i32,
2297 message_fields: None,
2298 };
2299 }
2300 impl MessageFields for IndexError {
2301 const FIELDS: &'static [&'static MessageField] = &[
2302 Self::INDEX_FIELD,
2303 Self::SUBRESULT_FIELD,
2304 ];
2305 }
2306 impl IndexError {
2307 pub fn path_builder() -> IndexErrorFieldPathBuilder {
2308 IndexErrorFieldPathBuilder::new()
2309 }
2310 }
2311 pub struct IndexErrorFieldPathBuilder {
2312 path: Vec<&'static str>,
2313 }
2314 impl IndexErrorFieldPathBuilder {
2315 #[allow(clippy::new_without_default)]
2316 pub fn new() -> Self {
2317 Self { path: Default::default() }
2318 }
2319 #[doc(hidden)]
2320 pub fn new_with_base(base: Vec<&'static str>) -> Self {
2321 Self { path: base }
2322 }
2323 pub fn finish(self) -> String {
2324 self.path.join(".")
2325 }
2326 pub fn index(mut self) -> String {
2327 self.path.push(IndexError::INDEX_FIELD.name);
2328 self.finish()
2329 }
2330 pub fn subresult(mut self) -> String {
2331 self.path.push(IndexError::SUBRESULT_FIELD.name);
2332 self.finish()
2333 }
2334 }
2335 impl CoinDenyListError {
2336 pub const ADDRESS_FIELD: &'static MessageField = &MessageField {
2337 name: "address",
2338 json_name: "address",
2339 number: 1i32,
2340 message_fields: None,
2341 };
2342 pub const COIN_TYPE_FIELD: &'static MessageField = &MessageField {
2343 name: "coin_type",
2344 json_name: "coinType",
2345 number: 2i32,
2346 message_fields: None,
2347 };
2348 }
2349 impl MessageFields for CoinDenyListError {
2350 const FIELDS: &'static [&'static MessageField] = &[
2351 Self::ADDRESS_FIELD,
2352 Self::COIN_TYPE_FIELD,
2353 ];
2354 }
2355 impl CoinDenyListError {
2356 pub fn path_builder() -> CoinDenyListErrorFieldPathBuilder {
2357 CoinDenyListErrorFieldPathBuilder::new()
2358 }
2359 }
2360 pub struct CoinDenyListErrorFieldPathBuilder {
2361 path: Vec<&'static str>,
2362 }
2363 impl CoinDenyListErrorFieldPathBuilder {
2364 #[allow(clippy::new_without_default)]
2365 pub fn new() -> Self {
2366 Self { path: Default::default() }
2367 }
2368 #[doc(hidden)]
2369 pub fn new_with_base(base: Vec<&'static str>) -> Self {
2370 Self { path: base }
2371 }
2372 pub fn finish(self) -> String {
2373 self.path.join(".")
2374 }
2375 pub fn address(mut self) -> String {
2376 self.path.push(CoinDenyListError::ADDRESS_FIELD.name);
2377 self.finish()
2378 }
2379 pub fn coin_type(mut self) -> String {
2380 self.path.push(CoinDenyListError::COIN_TYPE_FIELD.name);
2381 self.finish()
2382 }
2383 }
2384 impl CongestedObjects {
2385 pub const OBJECTS_FIELD: &'static MessageField = &MessageField {
2386 name: "objects",
2387 json_name: "objects",
2388 number: 1i32,
2389 message_fields: None,
2390 };
2391 }
2392 impl MessageFields for CongestedObjects {
2393 const FIELDS: &'static [&'static MessageField] = &[Self::OBJECTS_FIELD];
2394 }
2395 impl CongestedObjects {
2396 pub fn path_builder() -> CongestedObjectsFieldPathBuilder {
2397 CongestedObjectsFieldPathBuilder::new()
2398 }
2399 }
2400 pub struct CongestedObjectsFieldPathBuilder {
2401 path: Vec<&'static str>,
2402 }
2403 impl CongestedObjectsFieldPathBuilder {
2404 #[allow(clippy::new_without_default)]
2405 pub fn new() -> Self {
2406 Self { path: Default::default() }
2407 }
2408 #[doc(hidden)]
2409 pub fn new_with_base(base: Vec<&'static str>) -> Self {
2410 Self { path: base }
2411 }
2412 pub fn finish(self) -> String {
2413 self.path.join(".")
2414 }
2415 pub fn objects(mut self) -> String {
2416 self.path.push(CongestedObjects::OBJECTS_FIELD.name);
2417 self.finish()
2418 }
2419 }
2420 impl CommandArgumentError {
2421 pub const ARGUMENT_FIELD: &'static MessageField = &MessageField {
2422 name: "argument",
2423 json_name: "argument",
2424 number: 1i32,
2425 message_fields: None,
2426 };
2427 pub const KIND_FIELD: &'static MessageField = &MessageField {
2428 name: "kind",
2429 json_name: "kind",
2430 number: 2i32,
2431 message_fields: None,
2432 };
2433 pub const INDEX_ERROR_FIELD: &'static MessageField = &MessageField {
2434 name: "index_error",
2435 json_name: "indexError",
2436 number: 3i32,
2437 message_fields: Some(IndexError::FIELDS),
2438 };
2439 }
2440 impl MessageFields for CommandArgumentError {
2441 const FIELDS: &'static [&'static MessageField] = &[
2442 Self::ARGUMENT_FIELD,
2443 Self::KIND_FIELD,
2444 Self::INDEX_ERROR_FIELD,
2445 ];
2446 }
2447 impl CommandArgumentError {
2448 pub fn path_builder() -> CommandArgumentErrorFieldPathBuilder {
2449 CommandArgumentErrorFieldPathBuilder::new()
2450 }
2451 }
2452 pub struct CommandArgumentErrorFieldPathBuilder {
2453 path: Vec<&'static str>,
2454 }
2455 impl CommandArgumentErrorFieldPathBuilder {
2456 #[allow(clippy::new_without_default)]
2457 pub fn new() -> Self {
2458 Self { path: Default::default() }
2459 }
2460 #[doc(hidden)]
2461 pub fn new_with_base(base: Vec<&'static str>) -> Self {
2462 Self { path: base }
2463 }
2464 pub fn finish(self) -> String {
2465 self.path.join(".")
2466 }
2467 pub fn argument(mut self) -> String {
2468 self.path.push(CommandArgumentError::ARGUMENT_FIELD.name);
2469 self.finish()
2470 }
2471 pub fn kind(mut self) -> String {
2472 self.path.push(CommandArgumentError::KIND_FIELD.name);
2473 self.finish()
2474 }
2475 pub fn index_error(mut self) -> IndexErrorFieldPathBuilder {
2476 self.path.push(CommandArgumentError::INDEX_ERROR_FIELD.name);
2477 IndexErrorFieldPathBuilder::new_with_base(self.path)
2478 }
2479 }
2480 impl PackageUpgradeError {
2481 pub const KIND_FIELD: &'static MessageField = &MessageField {
2482 name: "kind",
2483 json_name: "kind",
2484 number: 1i32,
2485 message_fields: None,
2486 };
2487 pub const PACKAGE_ID_FIELD: &'static MessageField = &MessageField {
2488 name: "package_id",
2489 json_name: "packageId",
2490 number: 2i32,
2491 message_fields: None,
2492 };
2493 pub const DIGEST_FIELD: &'static MessageField = &MessageField {
2494 name: "digest",
2495 json_name: "digest",
2496 number: 3i32,
2497 message_fields: None,
2498 };
2499 pub const POLICY_FIELD: &'static MessageField = &MessageField {
2500 name: "policy",
2501 json_name: "policy",
2502 number: 4i32,
2503 message_fields: None,
2504 };
2505 pub const TICKET_ID_FIELD: &'static MessageField = &MessageField {
2506 name: "ticket_id",
2507 json_name: "ticketId",
2508 number: 5i32,
2509 message_fields: None,
2510 };
2511 }
2512 impl MessageFields for PackageUpgradeError {
2513 const FIELDS: &'static [&'static MessageField] = &[
2514 Self::KIND_FIELD,
2515 Self::PACKAGE_ID_FIELD,
2516 Self::DIGEST_FIELD,
2517 Self::POLICY_FIELD,
2518 Self::TICKET_ID_FIELD,
2519 ];
2520 }
2521 impl PackageUpgradeError {
2522 pub fn path_builder() -> PackageUpgradeErrorFieldPathBuilder {
2523 PackageUpgradeErrorFieldPathBuilder::new()
2524 }
2525 }
2526 pub struct PackageUpgradeErrorFieldPathBuilder {
2527 path: Vec<&'static str>,
2528 }
2529 impl PackageUpgradeErrorFieldPathBuilder {
2530 #[allow(clippy::new_without_default)]
2531 pub fn new() -> Self {
2532 Self { path: Default::default() }
2533 }
2534 #[doc(hidden)]
2535 pub fn new_with_base(base: Vec<&'static str>) -> Self {
2536 Self { path: base }
2537 }
2538 pub fn finish(self) -> String {
2539 self.path.join(".")
2540 }
2541 pub fn kind(mut self) -> String {
2542 self.path.push(PackageUpgradeError::KIND_FIELD.name);
2543 self.finish()
2544 }
2545 pub fn package_id(mut self) -> String {
2546 self.path.push(PackageUpgradeError::PACKAGE_ID_FIELD.name);
2547 self.finish()
2548 }
2549 pub fn digest(mut self) -> String {
2550 self.path.push(PackageUpgradeError::DIGEST_FIELD.name);
2551 self.finish()
2552 }
2553 pub fn policy(mut self) -> String {
2554 self.path.push(PackageUpgradeError::POLICY_FIELD.name);
2555 self.finish()
2556 }
2557 pub fn ticket_id(mut self) -> String {
2558 self.path.push(PackageUpgradeError::TICKET_ID_FIELD.name);
2559 self.finish()
2560 }
2561 }
2562 impl TypeArgumentError {
2563 pub const TYPE_ARGUMENT_FIELD: &'static MessageField = &MessageField {
2564 name: "type_argument",
2565 json_name: "typeArgument",
2566 number: 1i32,
2567 message_fields: None,
2568 };
2569 pub const KIND_FIELD: &'static MessageField = &MessageField {
2570 name: "kind",
2571 json_name: "kind",
2572 number: 2i32,
2573 message_fields: None,
2574 };
2575 }
2576 impl MessageFields for TypeArgumentError {
2577 const FIELDS: &'static [&'static MessageField] = &[
2578 Self::TYPE_ARGUMENT_FIELD,
2579 Self::KIND_FIELD,
2580 ];
2581 }
2582 impl TypeArgumentError {
2583 pub fn path_builder() -> TypeArgumentErrorFieldPathBuilder {
2584 TypeArgumentErrorFieldPathBuilder::new()
2585 }
2586 }
2587 pub struct TypeArgumentErrorFieldPathBuilder {
2588 path: Vec<&'static str>,
2589 }
2590 impl TypeArgumentErrorFieldPathBuilder {
2591 #[allow(clippy::new_without_default)]
2592 pub fn new() -> Self {
2593 Self { path: Default::default() }
2594 }
2595 #[doc(hidden)]
2596 pub fn new_with_base(base: Vec<&'static str>) -> Self {
2597 Self { path: base }
2598 }
2599 pub fn finish(self) -> String {
2600 self.path.join(".")
2601 }
2602 pub fn type_argument(mut self) -> String {
2603 self.path.push(TypeArgumentError::TYPE_ARGUMENT_FIELD.name);
2604 self.finish()
2605 }
2606 pub fn kind(mut self) -> String {
2607 self.path.push(TypeArgumentError::KIND_FIELD.name);
2608 self.finish()
2609 }
2610 }
2611 impl TransactionFilter {
2612 pub const TERMS_FIELD: &'static MessageField = &MessageField {
2613 name: "terms",
2614 json_name: "terms",
2615 number: 1i32,
2616 message_fields: Some(TransactionTerm::FIELDS),
2617 };
2618 }
2619 impl MessageFields for TransactionFilter {
2620 const FIELDS: &'static [&'static MessageField] = &[Self::TERMS_FIELD];
2621 }
2622 impl TransactionFilter {
2623 pub fn path_builder() -> TransactionFilterFieldPathBuilder {
2624 TransactionFilterFieldPathBuilder::new()
2625 }
2626 }
2627 pub struct TransactionFilterFieldPathBuilder {
2628 path: Vec<&'static str>,
2629 }
2630 impl TransactionFilterFieldPathBuilder {
2631 #[allow(clippy::new_without_default)]
2632 pub fn new() -> Self {
2633 Self { path: Default::default() }
2634 }
2635 #[doc(hidden)]
2636 pub fn new_with_base(base: Vec<&'static str>) -> Self {
2637 Self { path: base }
2638 }
2639 pub fn finish(self) -> String {
2640 self.path.join(".")
2641 }
2642 pub fn terms(mut self) -> TransactionTermFieldPathBuilder {
2643 self.path.push(TransactionFilter::TERMS_FIELD.name);
2644 TransactionTermFieldPathBuilder::new_with_base(self.path)
2645 }
2646 }
2647 impl TransactionTerm {
2648 pub const LITERALS_FIELD: &'static MessageField = &MessageField {
2649 name: "literals",
2650 json_name: "literals",
2651 number: 1i32,
2652 message_fields: Some(TransactionLiteral::FIELDS),
2653 };
2654 }
2655 impl MessageFields for TransactionTerm {
2656 const FIELDS: &'static [&'static MessageField] = &[Self::LITERALS_FIELD];
2657 }
2658 impl TransactionTerm {
2659 pub fn path_builder() -> TransactionTermFieldPathBuilder {
2660 TransactionTermFieldPathBuilder::new()
2661 }
2662 }
2663 pub struct TransactionTermFieldPathBuilder {
2664 path: Vec<&'static str>,
2665 }
2666 impl TransactionTermFieldPathBuilder {
2667 #[allow(clippy::new_without_default)]
2668 pub fn new() -> Self {
2669 Self { path: Default::default() }
2670 }
2671 #[doc(hidden)]
2672 pub fn new_with_base(base: Vec<&'static str>) -> Self {
2673 Self { path: base }
2674 }
2675 pub fn finish(self) -> String {
2676 self.path.join(".")
2677 }
2678 pub fn literals(mut self) -> TransactionLiteralFieldPathBuilder {
2679 self.path.push(TransactionTerm::LITERALS_FIELD.name);
2680 TransactionLiteralFieldPathBuilder::new_with_base(self.path)
2681 }
2682 }
2683 impl TransactionLiteral {
2684 pub const NEGATED_FIELD: &'static MessageField = &MessageField {
2685 name: "negated",
2686 json_name: "negated",
2687 number: 1i32,
2688 message_fields: None,
2689 };
2690 pub const SENDER_FIELD: &'static MessageField = &MessageField {
2691 name: "sender",
2692 json_name: "sender",
2693 number: 2i32,
2694 message_fields: Some(SenderFilter::FIELDS),
2695 };
2696 pub const AFFECTED_ADDRESS_FIELD: &'static MessageField = &MessageField {
2697 name: "affected_address",
2698 json_name: "affectedAddress",
2699 number: 3i32,
2700 message_fields: Some(AffectedAddressFilter::FIELDS),
2701 };
2702 pub const AFFECTED_OBJECT_FIELD: &'static MessageField = &MessageField {
2703 name: "affected_object",
2704 json_name: "affectedObject",
2705 number: 4i32,
2706 message_fields: Some(AffectedObjectFilter::FIELDS),
2707 };
2708 pub const MOVE_CALL_FIELD: &'static MessageField = &MessageField {
2709 name: "move_call",
2710 json_name: "moveCall",
2711 number: 5i32,
2712 message_fields: Some(MoveCallFilter::FIELDS),
2713 };
2714 pub const EMIT_MODULE_FIELD: &'static MessageField = &MessageField {
2715 name: "emit_module",
2716 json_name: "emitModule",
2717 number: 6i32,
2718 message_fields: Some(EmitModuleFilter::FIELDS),
2719 };
2720 pub const EVENT_TYPE_FIELD: &'static MessageField = &MessageField {
2721 name: "event_type",
2722 json_name: "eventType",
2723 number: 7i32,
2724 message_fields: Some(EventTypeFilter::FIELDS),
2725 };
2726 pub const EVENT_STREAM_HEAD_FIELD: &'static MessageField = &MessageField {
2727 name: "event_stream_head",
2728 json_name: "eventStreamHead",
2729 number: 8i32,
2730 message_fields: Some(EventStreamHeadFilter::FIELDS),
2731 };
2732 pub const PACKAGE_WRITE_FIELD: &'static MessageField = &MessageField {
2733 name: "package_write",
2734 json_name: "packageWrite",
2735 number: 9i32,
2736 message_fields: Some(PackageWriteFilter::FIELDS),
2737 };
2738 }
2739 impl MessageFields for TransactionLiteral {
2740 const FIELDS: &'static [&'static MessageField] = &[
2741 Self::NEGATED_FIELD,
2742 Self::SENDER_FIELD,
2743 Self::AFFECTED_ADDRESS_FIELD,
2744 Self::AFFECTED_OBJECT_FIELD,
2745 Self::MOVE_CALL_FIELD,
2746 Self::EMIT_MODULE_FIELD,
2747 Self::EVENT_TYPE_FIELD,
2748 Self::EVENT_STREAM_HEAD_FIELD,
2749 Self::PACKAGE_WRITE_FIELD,
2750 ];
2751 }
2752 impl TransactionLiteral {
2753 pub fn path_builder() -> TransactionLiteralFieldPathBuilder {
2754 TransactionLiteralFieldPathBuilder::new()
2755 }
2756 }
2757 pub struct TransactionLiteralFieldPathBuilder {
2758 path: Vec<&'static str>,
2759 }
2760 impl TransactionLiteralFieldPathBuilder {
2761 #[allow(clippy::new_without_default)]
2762 pub fn new() -> Self {
2763 Self { path: Default::default() }
2764 }
2765 #[doc(hidden)]
2766 pub fn new_with_base(base: Vec<&'static str>) -> Self {
2767 Self { path: base }
2768 }
2769 pub fn finish(self) -> String {
2770 self.path.join(".")
2771 }
2772 pub fn negated(mut self) -> String {
2773 self.path.push(TransactionLiteral::NEGATED_FIELD.name);
2774 self.finish()
2775 }
2776 pub fn sender(mut self) -> SenderFilterFieldPathBuilder {
2777 self.path.push(TransactionLiteral::SENDER_FIELD.name);
2778 SenderFilterFieldPathBuilder::new_with_base(self.path)
2779 }
2780 pub fn affected_address(mut self) -> AffectedAddressFilterFieldPathBuilder {
2781 self.path.push(TransactionLiteral::AFFECTED_ADDRESS_FIELD.name);
2782 AffectedAddressFilterFieldPathBuilder::new_with_base(self.path)
2783 }
2784 pub fn affected_object(mut self) -> AffectedObjectFilterFieldPathBuilder {
2785 self.path.push(TransactionLiteral::AFFECTED_OBJECT_FIELD.name);
2786 AffectedObjectFilterFieldPathBuilder::new_with_base(self.path)
2787 }
2788 pub fn move_call(mut self) -> MoveCallFilterFieldPathBuilder {
2789 self.path.push(TransactionLiteral::MOVE_CALL_FIELD.name);
2790 MoveCallFilterFieldPathBuilder::new_with_base(self.path)
2791 }
2792 pub fn emit_module(mut self) -> EmitModuleFilterFieldPathBuilder {
2793 self.path.push(TransactionLiteral::EMIT_MODULE_FIELD.name);
2794 EmitModuleFilterFieldPathBuilder::new_with_base(self.path)
2795 }
2796 pub fn event_type(mut self) -> EventTypeFilterFieldPathBuilder {
2797 self.path.push(TransactionLiteral::EVENT_TYPE_FIELD.name);
2798 EventTypeFilterFieldPathBuilder::new_with_base(self.path)
2799 }
2800 pub fn event_stream_head(mut self) -> EventStreamHeadFilterFieldPathBuilder {
2801 self.path.push(TransactionLiteral::EVENT_STREAM_HEAD_FIELD.name);
2802 EventStreamHeadFilterFieldPathBuilder::new_with_base(self.path)
2803 }
2804 pub fn package_write(mut self) -> PackageWriteFilterFieldPathBuilder {
2805 self.path.push(TransactionLiteral::PACKAGE_WRITE_FIELD.name);
2806 PackageWriteFilterFieldPathBuilder::new_with_base(self.path)
2807 }
2808 }
2809 impl EventFilter {
2810 pub const TERMS_FIELD: &'static MessageField = &MessageField {
2811 name: "terms",
2812 json_name: "terms",
2813 number: 1i32,
2814 message_fields: Some(EventTerm::FIELDS),
2815 };
2816 }
2817 impl MessageFields for EventFilter {
2818 const FIELDS: &'static [&'static MessageField] = &[Self::TERMS_FIELD];
2819 }
2820 impl EventFilter {
2821 pub fn path_builder() -> EventFilterFieldPathBuilder {
2822 EventFilterFieldPathBuilder::new()
2823 }
2824 }
2825 pub struct EventFilterFieldPathBuilder {
2826 path: Vec<&'static str>,
2827 }
2828 impl EventFilterFieldPathBuilder {
2829 #[allow(clippy::new_without_default)]
2830 pub fn new() -> Self {
2831 Self { path: Default::default() }
2832 }
2833 #[doc(hidden)]
2834 pub fn new_with_base(base: Vec<&'static str>) -> Self {
2835 Self { path: base }
2836 }
2837 pub fn finish(self) -> String {
2838 self.path.join(".")
2839 }
2840 pub fn terms(mut self) -> EventTermFieldPathBuilder {
2841 self.path.push(EventFilter::TERMS_FIELD.name);
2842 EventTermFieldPathBuilder::new_with_base(self.path)
2843 }
2844 }
2845 impl EventTerm {
2846 pub const LITERALS_FIELD: &'static MessageField = &MessageField {
2847 name: "literals",
2848 json_name: "literals",
2849 number: 1i32,
2850 message_fields: Some(EventLiteral::FIELDS),
2851 };
2852 }
2853 impl MessageFields for EventTerm {
2854 const FIELDS: &'static [&'static MessageField] = &[Self::LITERALS_FIELD];
2855 }
2856 impl EventTerm {
2857 pub fn path_builder() -> EventTermFieldPathBuilder {
2858 EventTermFieldPathBuilder::new()
2859 }
2860 }
2861 pub struct EventTermFieldPathBuilder {
2862 path: Vec<&'static str>,
2863 }
2864 impl EventTermFieldPathBuilder {
2865 #[allow(clippy::new_without_default)]
2866 pub fn new() -> Self {
2867 Self { path: Default::default() }
2868 }
2869 #[doc(hidden)]
2870 pub fn new_with_base(base: Vec<&'static str>) -> Self {
2871 Self { path: base }
2872 }
2873 pub fn finish(self) -> String {
2874 self.path.join(".")
2875 }
2876 pub fn literals(mut self) -> EventLiteralFieldPathBuilder {
2877 self.path.push(EventTerm::LITERALS_FIELD.name);
2878 EventLiteralFieldPathBuilder::new_with_base(self.path)
2879 }
2880 }
2881 impl EventLiteral {
2882 pub const NEGATED_FIELD: &'static MessageField = &MessageField {
2883 name: "negated",
2884 json_name: "negated",
2885 number: 1i32,
2886 message_fields: None,
2887 };
2888 pub const SENDER_FIELD: &'static MessageField = &MessageField {
2889 name: "sender",
2890 json_name: "sender",
2891 number: 2i32,
2892 message_fields: Some(SenderFilter::FIELDS),
2893 };
2894 pub const EMIT_MODULE_FIELD: &'static MessageField = &MessageField {
2895 name: "emit_module",
2896 json_name: "emitModule",
2897 number: 3i32,
2898 message_fields: Some(EmitModuleFilter::FIELDS),
2899 };
2900 pub const EVENT_TYPE_FIELD: &'static MessageField = &MessageField {
2901 name: "event_type",
2902 json_name: "eventType",
2903 number: 4i32,
2904 message_fields: Some(EventTypeFilter::FIELDS),
2905 };
2906 pub const EVENT_STREAM_HEAD_FIELD: &'static MessageField = &MessageField {
2907 name: "event_stream_head",
2908 json_name: "eventStreamHead",
2909 number: 5i32,
2910 message_fields: Some(EventStreamHeadFilter::FIELDS),
2911 };
2912 }
2913 impl MessageFields for EventLiteral {
2914 const FIELDS: &'static [&'static MessageField] = &[
2915 Self::NEGATED_FIELD,
2916 Self::SENDER_FIELD,
2917 Self::EMIT_MODULE_FIELD,
2918 Self::EVENT_TYPE_FIELD,
2919 Self::EVENT_STREAM_HEAD_FIELD,
2920 ];
2921 }
2922 impl EventLiteral {
2923 pub fn path_builder() -> EventLiteralFieldPathBuilder {
2924 EventLiteralFieldPathBuilder::new()
2925 }
2926 }
2927 pub struct EventLiteralFieldPathBuilder {
2928 path: Vec<&'static str>,
2929 }
2930 impl EventLiteralFieldPathBuilder {
2931 #[allow(clippy::new_without_default)]
2932 pub fn new() -> Self {
2933 Self { path: Default::default() }
2934 }
2935 #[doc(hidden)]
2936 pub fn new_with_base(base: Vec<&'static str>) -> Self {
2937 Self { path: base }
2938 }
2939 pub fn finish(self) -> String {
2940 self.path.join(".")
2941 }
2942 pub fn negated(mut self) -> String {
2943 self.path.push(EventLiteral::NEGATED_FIELD.name);
2944 self.finish()
2945 }
2946 pub fn sender(mut self) -> SenderFilterFieldPathBuilder {
2947 self.path.push(EventLiteral::SENDER_FIELD.name);
2948 SenderFilterFieldPathBuilder::new_with_base(self.path)
2949 }
2950 pub fn emit_module(mut self) -> EmitModuleFilterFieldPathBuilder {
2951 self.path.push(EventLiteral::EMIT_MODULE_FIELD.name);
2952 EmitModuleFilterFieldPathBuilder::new_with_base(self.path)
2953 }
2954 pub fn event_type(mut self) -> EventTypeFilterFieldPathBuilder {
2955 self.path.push(EventLiteral::EVENT_TYPE_FIELD.name);
2956 EventTypeFilterFieldPathBuilder::new_with_base(self.path)
2957 }
2958 pub fn event_stream_head(mut self) -> EventStreamHeadFilterFieldPathBuilder {
2959 self.path.push(EventLiteral::EVENT_STREAM_HEAD_FIELD.name);
2960 EventStreamHeadFilterFieldPathBuilder::new_with_base(self.path)
2961 }
2962 }
2963 impl SenderFilter {
2964 pub const ADDRESS_FIELD: &'static MessageField = &MessageField {
2965 name: "address",
2966 json_name: "address",
2967 number: 1i32,
2968 message_fields: None,
2969 };
2970 }
2971 impl MessageFields for SenderFilter {
2972 const FIELDS: &'static [&'static MessageField] = &[Self::ADDRESS_FIELD];
2973 }
2974 impl SenderFilter {
2975 pub fn path_builder() -> SenderFilterFieldPathBuilder {
2976 SenderFilterFieldPathBuilder::new()
2977 }
2978 }
2979 pub struct SenderFilterFieldPathBuilder {
2980 path: Vec<&'static str>,
2981 }
2982 impl SenderFilterFieldPathBuilder {
2983 #[allow(clippy::new_without_default)]
2984 pub fn new() -> Self {
2985 Self { path: Default::default() }
2986 }
2987 #[doc(hidden)]
2988 pub fn new_with_base(base: Vec<&'static str>) -> Self {
2989 Self { path: base }
2990 }
2991 pub fn finish(self) -> String {
2992 self.path.join(".")
2993 }
2994 pub fn address(mut self) -> String {
2995 self.path.push(SenderFilter::ADDRESS_FIELD.name);
2996 self.finish()
2997 }
2998 }
2999 impl AffectedAddressFilter {
3000 pub const ADDRESS_FIELD: &'static MessageField = &MessageField {
3001 name: "address",
3002 json_name: "address",
3003 number: 1i32,
3004 message_fields: None,
3005 };
3006 }
3007 impl MessageFields for AffectedAddressFilter {
3008 const FIELDS: &'static [&'static MessageField] = &[Self::ADDRESS_FIELD];
3009 }
3010 impl AffectedAddressFilter {
3011 pub fn path_builder() -> AffectedAddressFilterFieldPathBuilder {
3012 AffectedAddressFilterFieldPathBuilder::new()
3013 }
3014 }
3015 pub struct AffectedAddressFilterFieldPathBuilder {
3016 path: Vec<&'static str>,
3017 }
3018 impl AffectedAddressFilterFieldPathBuilder {
3019 #[allow(clippy::new_without_default)]
3020 pub fn new() -> Self {
3021 Self { path: Default::default() }
3022 }
3023 #[doc(hidden)]
3024 pub fn new_with_base(base: Vec<&'static str>) -> Self {
3025 Self { path: base }
3026 }
3027 pub fn finish(self) -> String {
3028 self.path.join(".")
3029 }
3030 pub fn address(mut self) -> String {
3031 self.path.push(AffectedAddressFilter::ADDRESS_FIELD.name);
3032 self.finish()
3033 }
3034 }
3035 impl AffectedObjectFilter {
3036 pub const OBJECT_ID_FIELD: &'static MessageField = &MessageField {
3037 name: "object_id",
3038 json_name: "objectId",
3039 number: 1i32,
3040 message_fields: None,
3041 };
3042 }
3043 impl MessageFields for AffectedObjectFilter {
3044 const FIELDS: &'static [&'static MessageField] = &[Self::OBJECT_ID_FIELD];
3045 }
3046 impl AffectedObjectFilter {
3047 pub fn path_builder() -> AffectedObjectFilterFieldPathBuilder {
3048 AffectedObjectFilterFieldPathBuilder::new()
3049 }
3050 }
3051 pub struct AffectedObjectFilterFieldPathBuilder {
3052 path: Vec<&'static str>,
3053 }
3054 impl AffectedObjectFilterFieldPathBuilder {
3055 #[allow(clippy::new_without_default)]
3056 pub fn new() -> Self {
3057 Self { path: Default::default() }
3058 }
3059 #[doc(hidden)]
3060 pub fn new_with_base(base: Vec<&'static str>) -> Self {
3061 Self { path: base }
3062 }
3063 pub fn finish(self) -> String {
3064 self.path.join(".")
3065 }
3066 pub fn object_id(mut self) -> String {
3067 self.path.push(AffectedObjectFilter::OBJECT_ID_FIELD.name);
3068 self.finish()
3069 }
3070 }
3071 impl MoveCallFilter {
3072 pub const FUNCTION_FIELD: &'static MessageField = &MessageField {
3073 name: "function",
3074 json_name: "function",
3075 number: 1i32,
3076 message_fields: None,
3077 };
3078 }
3079 impl MessageFields for MoveCallFilter {
3080 const FIELDS: &'static [&'static MessageField] = &[Self::FUNCTION_FIELD];
3081 }
3082 impl MoveCallFilter {
3083 pub fn path_builder() -> MoveCallFilterFieldPathBuilder {
3084 MoveCallFilterFieldPathBuilder::new()
3085 }
3086 }
3087 pub struct MoveCallFilterFieldPathBuilder {
3088 path: Vec<&'static str>,
3089 }
3090 impl MoveCallFilterFieldPathBuilder {
3091 #[allow(clippy::new_without_default)]
3092 pub fn new() -> Self {
3093 Self { path: Default::default() }
3094 }
3095 #[doc(hidden)]
3096 pub fn new_with_base(base: Vec<&'static str>) -> Self {
3097 Self { path: base }
3098 }
3099 pub fn finish(self) -> String {
3100 self.path.join(".")
3101 }
3102 pub fn function(mut self) -> String {
3103 self.path.push(MoveCallFilter::FUNCTION_FIELD.name);
3104 self.finish()
3105 }
3106 }
3107 impl EmitModuleFilter {
3108 pub const MODULE_FIELD: &'static MessageField = &MessageField {
3109 name: "module",
3110 json_name: "module",
3111 number: 1i32,
3112 message_fields: None,
3113 };
3114 }
3115 impl MessageFields for EmitModuleFilter {
3116 const FIELDS: &'static [&'static MessageField] = &[Self::MODULE_FIELD];
3117 }
3118 impl EmitModuleFilter {
3119 pub fn path_builder() -> EmitModuleFilterFieldPathBuilder {
3120 EmitModuleFilterFieldPathBuilder::new()
3121 }
3122 }
3123 pub struct EmitModuleFilterFieldPathBuilder {
3124 path: Vec<&'static str>,
3125 }
3126 impl EmitModuleFilterFieldPathBuilder {
3127 #[allow(clippy::new_without_default)]
3128 pub fn new() -> Self {
3129 Self { path: Default::default() }
3130 }
3131 #[doc(hidden)]
3132 pub fn new_with_base(base: Vec<&'static str>) -> Self {
3133 Self { path: base }
3134 }
3135 pub fn finish(self) -> String {
3136 self.path.join(".")
3137 }
3138 pub fn module(mut self) -> String {
3139 self.path.push(EmitModuleFilter::MODULE_FIELD.name);
3140 self.finish()
3141 }
3142 }
3143 impl EventTypeFilter {
3144 pub const EVENT_TYPE_FIELD: &'static MessageField = &MessageField {
3145 name: "event_type",
3146 json_name: "eventType",
3147 number: 1i32,
3148 message_fields: None,
3149 };
3150 }
3151 impl MessageFields for EventTypeFilter {
3152 const FIELDS: &'static [&'static MessageField] = &[Self::EVENT_TYPE_FIELD];
3153 }
3154 impl EventTypeFilter {
3155 pub fn path_builder() -> EventTypeFilterFieldPathBuilder {
3156 EventTypeFilterFieldPathBuilder::new()
3157 }
3158 }
3159 pub struct EventTypeFilterFieldPathBuilder {
3160 path: Vec<&'static str>,
3161 }
3162 impl EventTypeFilterFieldPathBuilder {
3163 #[allow(clippy::new_without_default)]
3164 pub fn new() -> Self {
3165 Self { path: Default::default() }
3166 }
3167 #[doc(hidden)]
3168 pub fn new_with_base(base: Vec<&'static str>) -> Self {
3169 Self { path: base }
3170 }
3171 pub fn finish(self) -> String {
3172 self.path.join(".")
3173 }
3174 pub fn event_type(mut self) -> String {
3175 self.path.push(EventTypeFilter::EVENT_TYPE_FIELD.name);
3176 self.finish()
3177 }
3178 }
3179 impl EventStreamHeadFilter {
3180 pub const STREAM_ID_FIELD: &'static MessageField = &MessageField {
3181 name: "stream_id",
3182 json_name: "streamId",
3183 number: 1i32,
3184 message_fields: None,
3185 };
3186 }
3187 impl MessageFields for EventStreamHeadFilter {
3188 const FIELDS: &'static [&'static MessageField] = &[Self::STREAM_ID_FIELD];
3189 }
3190 impl EventStreamHeadFilter {
3191 pub fn path_builder() -> EventStreamHeadFilterFieldPathBuilder {
3192 EventStreamHeadFilterFieldPathBuilder::new()
3193 }
3194 }
3195 pub struct EventStreamHeadFilterFieldPathBuilder {
3196 path: Vec<&'static str>,
3197 }
3198 impl EventStreamHeadFilterFieldPathBuilder {
3199 #[allow(clippy::new_without_default)]
3200 pub fn new() -> Self {
3201 Self { path: Default::default() }
3202 }
3203 #[doc(hidden)]
3204 pub fn new_with_base(base: Vec<&'static str>) -> Self {
3205 Self { path: base }
3206 }
3207 pub fn finish(self) -> String {
3208 self.path.join(".")
3209 }
3210 pub fn stream_id(mut self) -> String {
3211 self.path.push(EventStreamHeadFilter::STREAM_ID_FIELD.name);
3212 self.finish()
3213 }
3214 }
3215 impl PackageWriteFilter {}
3216 impl MessageFields for PackageWriteFilter {
3217 const FIELDS: &'static [&'static MessageField] = &[];
3218 }
3219 impl PackageWriteFilter {
3220 pub fn path_builder() -> PackageWriteFilterFieldPathBuilder {
3221 PackageWriteFilterFieldPathBuilder::new()
3222 }
3223 }
3224 pub struct PackageWriteFilterFieldPathBuilder {
3225 path: Vec<&'static str>,
3226 }
3227 impl PackageWriteFilterFieldPathBuilder {
3228 #[allow(clippy::new_without_default)]
3229 pub fn new() -> Self {
3230 Self { path: Default::default() }
3231 }
3232 #[doc(hidden)]
3233 pub fn new_with_base(base: Vec<&'static str>) -> Self {
3234 Self { path: base }
3235 }
3236 pub fn finish(self) -> String {
3237 self.path.join(".")
3238 }
3239 }
3240 impl GasCostSummary {
3241 pub const COMPUTATION_COST_FIELD: &'static MessageField = &MessageField {
3242 name: "computation_cost",
3243 json_name: "computationCost",
3244 number: 1i32,
3245 message_fields: None,
3246 };
3247 pub const STORAGE_COST_FIELD: &'static MessageField = &MessageField {
3248 name: "storage_cost",
3249 json_name: "storageCost",
3250 number: 2i32,
3251 message_fields: None,
3252 };
3253 pub const STORAGE_REBATE_FIELD: &'static MessageField = &MessageField {
3254 name: "storage_rebate",
3255 json_name: "storageRebate",
3256 number: 3i32,
3257 message_fields: None,
3258 };
3259 pub const NON_REFUNDABLE_STORAGE_FEE_FIELD: &'static MessageField = &MessageField {
3260 name: "non_refundable_storage_fee",
3261 json_name: "nonRefundableStorageFee",
3262 number: 4i32,
3263 message_fields: None,
3264 };
3265 }
3266 impl MessageFields for GasCostSummary {
3267 const FIELDS: &'static [&'static MessageField] = &[
3268 Self::COMPUTATION_COST_FIELD,
3269 Self::STORAGE_COST_FIELD,
3270 Self::STORAGE_REBATE_FIELD,
3271 Self::NON_REFUNDABLE_STORAGE_FEE_FIELD,
3272 ];
3273 }
3274 impl GasCostSummary {
3275 pub fn path_builder() -> GasCostSummaryFieldPathBuilder {
3276 GasCostSummaryFieldPathBuilder::new()
3277 }
3278 }
3279 pub struct GasCostSummaryFieldPathBuilder {
3280 path: Vec<&'static str>,
3281 }
3282 impl GasCostSummaryFieldPathBuilder {
3283 #[allow(clippy::new_without_default)]
3284 pub fn new() -> Self {
3285 Self { path: Default::default() }
3286 }
3287 #[doc(hidden)]
3288 pub fn new_with_base(base: Vec<&'static str>) -> Self {
3289 Self { path: base }
3290 }
3291 pub fn finish(self) -> String {
3292 self.path.join(".")
3293 }
3294 pub fn computation_cost(mut self) -> String {
3295 self.path.push(GasCostSummary::COMPUTATION_COST_FIELD.name);
3296 self.finish()
3297 }
3298 pub fn storage_cost(mut self) -> String {
3299 self.path.push(GasCostSummary::STORAGE_COST_FIELD.name);
3300 self.finish()
3301 }
3302 pub fn storage_rebate(mut self) -> String {
3303 self.path.push(GasCostSummary::STORAGE_REBATE_FIELD.name);
3304 self.finish()
3305 }
3306 pub fn non_refundable_storage_fee(mut self) -> String {
3307 self.path.push(GasCostSummary::NON_REFUNDABLE_STORAGE_FEE_FIELD.name);
3308 self.finish()
3309 }
3310 }
3311 impl Input {
3312 pub const KIND_FIELD: &'static MessageField = &MessageField {
3313 name: "kind",
3314 json_name: "kind",
3315 number: 1i32,
3316 message_fields: None,
3317 };
3318 pub const PURE_FIELD: &'static MessageField = &MessageField {
3319 name: "pure",
3320 json_name: "pure",
3321 number: 2i32,
3322 message_fields: None,
3323 };
3324 pub const OBJECT_ID_FIELD: &'static MessageField = &MessageField {
3325 name: "object_id",
3326 json_name: "objectId",
3327 number: 3i32,
3328 message_fields: None,
3329 };
3330 pub const VERSION_FIELD: &'static MessageField = &MessageField {
3331 name: "version",
3332 json_name: "version",
3333 number: 4i32,
3334 message_fields: None,
3335 };
3336 pub const DIGEST_FIELD: &'static MessageField = &MessageField {
3337 name: "digest",
3338 json_name: "digest",
3339 number: 5i32,
3340 message_fields: None,
3341 };
3342 pub const MUTABLE_FIELD: &'static MessageField = &MessageField {
3343 name: "mutable",
3344 json_name: "mutable",
3345 number: 6i32,
3346 message_fields: None,
3347 };
3348 pub const MUTABILITY_FIELD: &'static MessageField = &MessageField {
3349 name: "mutability",
3350 json_name: "mutability",
3351 number: 7i32,
3352 message_fields: None,
3353 };
3354 pub const FUNDS_WITHDRAWAL_FIELD: &'static MessageField = &MessageField {
3355 name: "funds_withdrawal",
3356 json_name: "fundsWithdrawal",
3357 number: 8i32,
3358 message_fields: Some(FundsWithdrawal::FIELDS),
3359 };
3360 pub const LITERAL_FIELD: &'static MessageField = &MessageField {
3361 name: "literal",
3362 json_name: "literal",
3363 number: 1000i32,
3364 message_fields: None,
3365 };
3366 }
3367 impl MessageFields for Input {
3368 const FIELDS: &'static [&'static MessageField] = &[
3369 Self::KIND_FIELD,
3370 Self::PURE_FIELD,
3371 Self::OBJECT_ID_FIELD,
3372 Self::VERSION_FIELD,
3373 Self::DIGEST_FIELD,
3374 Self::MUTABLE_FIELD,
3375 Self::MUTABILITY_FIELD,
3376 Self::FUNDS_WITHDRAWAL_FIELD,
3377 Self::LITERAL_FIELD,
3378 ];
3379 }
3380 impl Input {
3381 pub fn path_builder() -> InputFieldPathBuilder {
3382 InputFieldPathBuilder::new()
3383 }
3384 }
3385 pub struct InputFieldPathBuilder {
3386 path: Vec<&'static str>,
3387 }
3388 impl InputFieldPathBuilder {
3389 #[allow(clippy::new_without_default)]
3390 pub fn new() -> Self {
3391 Self { path: Default::default() }
3392 }
3393 #[doc(hidden)]
3394 pub fn new_with_base(base: Vec<&'static str>) -> Self {
3395 Self { path: base }
3396 }
3397 pub fn finish(self) -> String {
3398 self.path.join(".")
3399 }
3400 pub fn kind(mut self) -> String {
3401 self.path.push(Input::KIND_FIELD.name);
3402 self.finish()
3403 }
3404 pub fn pure(mut self) -> String {
3405 self.path.push(Input::PURE_FIELD.name);
3406 self.finish()
3407 }
3408 pub fn object_id(mut self) -> String {
3409 self.path.push(Input::OBJECT_ID_FIELD.name);
3410 self.finish()
3411 }
3412 pub fn version(mut self) -> String {
3413 self.path.push(Input::VERSION_FIELD.name);
3414 self.finish()
3415 }
3416 pub fn digest(mut self) -> String {
3417 self.path.push(Input::DIGEST_FIELD.name);
3418 self.finish()
3419 }
3420 pub fn mutable(mut self) -> String {
3421 self.path.push(Input::MUTABLE_FIELD.name);
3422 self.finish()
3423 }
3424 pub fn mutability(mut self) -> String {
3425 self.path.push(Input::MUTABILITY_FIELD.name);
3426 self.finish()
3427 }
3428 pub fn funds_withdrawal(mut self) -> FundsWithdrawalFieldPathBuilder {
3429 self.path.push(Input::FUNDS_WITHDRAWAL_FIELD.name);
3430 FundsWithdrawalFieldPathBuilder::new_with_base(self.path)
3431 }
3432 pub fn literal(mut self) -> String {
3433 self.path.push(Input::LITERAL_FIELD.name);
3434 self.finish()
3435 }
3436 }
3437 impl FundsWithdrawal {
3438 pub const AMOUNT_FIELD: &'static MessageField = &MessageField {
3439 name: "amount",
3440 json_name: "amount",
3441 number: 1i32,
3442 message_fields: None,
3443 };
3444 pub const COIN_TYPE_FIELD: &'static MessageField = &MessageField {
3445 name: "coin_type",
3446 json_name: "coinType",
3447 number: 2i32,
3448 message_fields: None,
3449 };
3450 pub const SOURCE_FIELD: &'static MessageField = &MessageField {
3451 name: "source",
3452 json_name: "source",
3453 number: 3i32,
3454 message_fields: None,
3455 };
3456 pub const FUNDER_FIELD: &'static MessageField = &MessageField {
3457 name: "funder",
3458 json_name: "funder",
3459 number: 4i32,
3460 message_fields: None,
3461 };
3462 pub const ALLOWANCE_FIELD: &'static MessageField = &MessageField {
3463 name: "allowance",
3464 json_name: "allowance",
3465 number: 5i32,
3466 message_fields: None,
3467 };
3468 }
3469 impl MessageFields for FundsWithdrawal {
3470 const FIELDS: &'static [&'static MessageField] = &[
3471 Self::AMOUNT_FIELD,
3472 Self::COIN_TYPE_FIELD,
3473 Self::SOURCE_FIELD,
3474 Self::FUNDER_FIELD,
3475 Self::ALLOWANCE_FIELD,
3476 ];
3477 }
3478 impl FundsWithdrawal {
3479 pub fn path_builder() -> FundsWithdrawalFieldPathBuilder {
3480 FundsWithdrawalFieldPathBuilder::new()
3481 }
3482 }
3483 pub struct FundsWithdrawalFieldPathBuilder {
3484 path: Vec<&'static str>,
3485 }
3486 impl FundsWithdrawalFieldPathBuilder {
3487 #[allow(clippy::new_without_default)]
3488 pub fn new() -> Self {
3489 Self { path: Default::default() }
3490 }
3491 #[doc(hidden)]
3492 pub fn new_with_base(base: Vec<&'static str>) -> Self {
3493 Self { path: base }
3494 }
3495 pub fn finish(self) -> String {
3496 self.path.join(".")
3497 }
3498 pub fn amount(mut self) -> String {
3499 self.path.push(FundsWithdrawal::AMOUNT_FIELD.name);
3500 self.finish()
3501 }
3502 pub fn coin_type(mut self) -> String {
3503 self.path.push(FundsWithdrawal::COIN_TYPE_FIELD.name);
3504 self.finish()
3505 }
3506 pub fn source(mut self) -> String {
3507 self.path.push(FundsWithdrawal::SOURCE_FIELD.name);
3508 self.finish()
3509 }
3510 pub fn funder(mut self) -> String {
3511 self.path.push(FundsWithdrawal::FUNDER_FIELD.name);
3512 self.finish()
3513 }
3514 pub fn allowance(mut self) -> String {
3515 self.path.push(FundsWithdrawal::ALLOWANCE_FIELD.name);
3516 self.finish()
3517 }
3518 }
3519 impl JwkId {
3520 pub const ISS_FIELD: &'static MessageField = &MessageField {
3521 name: "iss",
3522 json_name: "iss",
3523 number: 1i32,
3524 message_fields: None,
3525 };
3526 pub const KID_FIELD: &'static MessageField = &MessageField {
3527 name: "kid",
3528 json_name: "kid",
3529 number: 2i32,
3530 message_fields: None,
3531 };
3532 }
3533 impl MessageFields for JwkId {
3534 const FIELDS: &'static [&'static MessageField] = &[
3535 Self::ISS_FIELD,
3536 Self::KID_FIELD,
3537 ];
3538 }
3539 impl JwkId {
3540 pub fn path_builder() -> JwkIdFieldPathBuilder {
3541 JwkIdFieldPathBuilder::new()
3542 }
3543 }
3544 pub struct JwkIdFieldPathBuilder {
3545 path: Vec<&'static str>,
3546 }
3547 impl JwkIdFieldPathBuilder {
3548 #[allow(clippy::new_without_default)]
3549 pub fn new() -> Self {
3550 Self { path: Default::default() }
3551 }
3552 #[doc(hidden)]
3553 pub fn new_with_base(base: Vec<&'static str>) -> Self {
3554 Self { path: base }
3555 }
3556 pub fn finish(self) -> String {
3557 self.path.join(".")
3558 }
3559 pub fn iss(mut self) -> String {
3560 self.path.push(JwkId::ISS_FIELD.name);
3561 self.finish()
3562 }
3563 pub fn kid(mut self) -> String {
3564 self.path.push(JwkId::KID_FIELD.name);
3565 self.finish()
3566 }
3567 }
3568 impl Jwk {
3569 pub const KTY_FIELD: &'static MessageField = &MessageField {
3570 name: "kty",
3571 json_name: "kty",
3572 number: 1i32,
3573 message_fields: None,
3574 };
3575 pub const E_FIELD: &'static MessageField = &MessageField {
3576 name: "e",
3577 json_name: "e",
3578 number: 2i32,
3579 message_fields: None,
3580 };
3581 pub const N_FIELD: &'static MessageField = &MessageField {
3582 name: "n",
3583 json_name: "n",
3584 number: 3i32,
3585 message_fields: None,
3586 };
3587 pub const ALG_FIELD: &'static MessageField = &MessageField {
3588 name: "alg",
3589 json_name: "alg",
3590 number: 4i32,
3591 message_fields: None,
3592 };
3593 }
3594 impl MessageFields for Jwk {
3595 const FIELDS: &'static [&'static MessageField] = &[
3596 Self::KTY_FIELD,
3597 Self::E_FIELD,
3598 Self::N_FIELD,
3599 Self::ALG_FIELD,
3600 ];
3601 }
3602 impl Jwk {
3603 pub fn path_builder() -> JwkFieldPathBuilder {
3604 JwkFieldPathBuilder::new()
3605 }
3606 }
3607 pub struct JwkFieldPathBuilder {
3608 path: Vec<&'static str>,
3609 }
3610 impl JwkFieldPathBuilder {
3611 #[allow(clippy::new_without_default)]
3612 pub fn new() -> Self {
3613 Self { path: Default::default() }
3614 }
3615 #[doc(hidden)]
3616 pub fn new_with_base(base: Vec<&'static str>) -> Self {
3617 Self { path: base }
3618 }
3619 pub fn finish(self) -> String {
3620 self.path.join(".")
3621 }
3622 pub fn kty(mut self) -> String {
3623 self.path.push(Jwk::KTY_FIELD.name);
3624 self.finish()
3625 }
3626 pub fn e(mut self) -> String {
3627 self.path.push(Jwk::E_FIELD.name);
3628 self.finish()
3629 }
3630 pub fn n(mut self) -> String {
3631 self.path.push(Jwk::N_FIELD.name);
3632 self.finish()
3633 }
3634 pub fn alg(mut self) -> String {
3635 self.path.push(Jwk::ALG_FIELD.name);
3636 self.finish()
3637 }
3638 }
3639 impl GetServiceInfoRequest {}
3640 impl MessageFields for GetServiceInfoRequest {
3641 const FIELDS: &'static [&'static MessageField] = &[];
3642 }
3643 impl GetServiceInfoRequest {
3644 pub fn path_builder() -> GetServiceInfoRequestFieldPathBuilder {
3645 GetServiceInfoRequestFieldPathBuilder::new()
3646 }
3647 }
3648 pub struct GetServiceInfoRequestFieldPathBuilder {
3649 path: Vec<&'static str>,
3650 }
3651 impl GetServiceInfoRequestFieldPathBuilder {
3652 #[allow(clippy::new_without_default)]
3653 pub fn new() -> Self {
3654 Self { path: Default::default() }
3655 }
3656 #[doc(hidden)]
3657 pub fn new_with_base(base: Vec<&'static str>) -> Self {
3658 Self { path: base }
3659 }
3660 pub fn finish(self) -> String {
3661 self.path.join(".")
3662 }
3663 }
3664 impl GetServiceInfoResponse {
3665 pub const CHAIN_ID_FIELD: &'static MessageField = &MessageField {
3666 name: "chain_id",
3667 json_name: "chainId",
3668 number: 1i32,
3669 message_fields: None,
3670 };
3671 pub const CHAIN_FIELD: &'static MessageField = &MessageField {
3672 name: "chain",
3673 json_name: "chain",
3674 number: 2i32,
3675 message_fields: None,
3676 };
3677 pub const EPOCH_FIELD: &'static MessageField = &MessageField {
3678 name: "epoch",
3679 json_name: "epoch",
3680 number: 3i32,
3681 message_fields: None,
3682 };
3683 pub const CHECKPOINT_HEIGHT_FIELD: &'static MessageField = &MessageField {
3684 name: "checkpoint_height",
3685 json_name: "checkpointHeight",
3686 number: 4i32,
3687 message_fields: None,
3688 };
3689 pub const TIMESTAMP_FIELD: &'static MessageField = &MessageField {
3690 name: "timestamp",
3691 json_name: "timestamp",
3692 number: 5i32,
3693 message_fields: None,
3694 };
3695 pub const LOWEST_AVAILABLE_CHECKPOINT_FIELD: &'static MessageField = &MessageField {
3696 name: "lowest_available_checkpoint",
3697 json_name: "lowestAvailableCheckpoint",
3698 number: 6i32,
3699 message_fields: None,
3700 };
3701 pub const LOWEST_AVAILABLE_CHECKPOINT_OBJECTS_FIELD: &'static MessageField = &MessageField {
3702 name: "lowest_available_checkpoint_objects",
3703 json_name: "lowestAvailableCheckpointObjects",
3704 number: 7i32,
3705 message_fields: None,
3706 };
3707 pub const SERVER_FIELD: &'static MessageField = &MessageField {
3708 name: "server",
3709 json_name: "server",
3710 number: 8i32,
3711 message_fields: None,
3712 };
3713 }
3714 impl MessageFields for GetServiceInfoResponse {
3715 const FIELDS: &'static [&'static MessageField] = &[
3716 Self::CHAIN_ID_FIELD,
3717 Self::CHAIN_FIELD,
3718 Self::EPOCH_FIELD,
3719 Self::CHECKPOINT_HEIGHT_FIELD,
3720 Self::TIMESTAMP_FIELD,
3721 Self::LOWEST_AVAILABLE_CHECKPOINT_FIELD,
3722 Self::LOWEST_AVAILABLE_CHECKPOINT_OBJECTS_FIELD,
3723 Self::SERVER_FIELD,
3724 ];
3725 }
3726 impl GetServiceInfoResponse {
3727 pub fn path_builder() -> GetServiceInfoResponseFieldPathBuilder {
3728 GetServiceInfoResponseFieldPathBuilder::new()
3729 }
3730 }
3731 pub struct GetServiceInfoResponseFieldPathBuilder {
3732 path: Vec<&'static str>,
3733 }
3734 impl GetServiceInfoResponseFieldPathBuilder {
3735 #[allow(clippy::new_without_default)]
3736 pub fn new() -> Self {
3737 Self { path: Default::default() }
3738 }
3739 #[doc(hidden)]
3740 pub fn new_with_base(base: Vec<&'static str>) -> Self {
3741 Self { path: base }
3742 }
3743 pub fn finish(self) -> String {
3744 self.path.join(".")
3745 }
3746 pub fn chain_id(mut self) -> String {
3747 self.path.push(GetServiceInfoResponse::CHAIN_ID_FIELD.name);
3748 self.finish()
3749 }
3750 pub fn chain(mut self) -> String {
3751 self.path.push(GetServiceInfoResponse::CHAIN_FIELD.name);
3752 self.finish()
3753 }
3754 pub fn epoch(mut self) -> String {
3755 self.path.push(GetServiceInfoResponse::EPOCH_FIELD.name);
3756 self.finish()
3757 }
3758 pub fn checkpoint_height(mut self) -> String {
3759 self.path.push(GetServiceInfoResponse::CHECKPOINT_HEIGHT_FIELD.name);
3760 self.finish()
3761 }
3762 pub fn timestamp(mut self) -> String {
3763 self.path.push(GetServiceInfoResponse::TIMESTAMP_FIELD.name);
3764 self.finish()
3765 }
3766 pub fn lowest_available_checkpoint(mut self) -> String {
3767 self.path
3768 .push(GetServiceInfoResponse::LOWEST_AVAILABLE_CHECKPOINT_FIELD.name);
3769 self.finish()
3770 }
3771 pub fn lowest_available_checkpoint_objects(mut self) -> String {
3772 self.path
3773 .push(
3774 GetServiceInfoResponse::LOWEST_AVAILABLE_CHECKPOINT_OBJECTS_FIELD
3775 .name,
3776 );
3777 self.finish()
3778 }
3779 pub fn server(mut self) -> String {
3780 self.path.push(GetServiceInfoResponse::SERVER_FIELD.name);
3781 self.finish()
3782 }
3783 }
3784 impl GetObjectRequest {
3785 pub const OBJECT_ID_FIELD: &'static MessageField = &MessageField {
3786 name: "object_id",
3787 json_name: "objectId",
3788 number: 1i32,
3789 message_fields: None,
3790 };
3791 pub const VERSION_FIELD: &'static MessageField = &MessageField {
3792 name: "version",
3793 json_name: "version",
3794 number: 2i32,
3795 message_fields: None,
3796 };
3797 pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
3798 name: "read_mask",
3799 json_name: "readMask",
3800 number: 3i32,
3801 message_fields: None,
3802 };
3803 }
3804 impl MessageFields for GetObjectRequest {
3805 const FIELDS: &'static [&'static MessageField] = &[
3806 Self::OBJECT_ID_FIELD,
3807 Self::VERSION_FIELD,
3808 Self::READ_MASK_FIELD,
3809 ];
3810 }
3811 impl GetObjectRequest {
3812 pub fn path_builder() -> GetObjectRequestFieldPathBuilder {
3813 GetObjectRequestFieldPathBuilder::new()
3814 }
3815 }
3816 pub struct GetObjectRequestFieldPathBuilder {
3817 path: Vec<&'static str>,
3818 }
3819 impl GetObjectRequestFieldPathBuilder {
3820 #[allow(clippy::new_without_default)]
3821 pub fn new() -> Self {
3822 Self { path: Default::default() }
3823 }
3824 #[doc(hidden)]
3825 pub fn new_with_base(base: Vec<&'static str>) -> Self {
3826 Self { path: base }
3827 }
3828 pub fn finish(self) -> String {
3829 self.path.join(".")
3830 }
3831 pub fn object_id(mut self) -> String {
3832 self.path.push(GetObjectRequest::OBJECT_ID_FIELD.name);
3833 self.finish()
3834 }
3835 pub fn version(mut self) -> String {
3836 self.path.push(GetObjectRequest::VERSION_FIELD.name);
3837 self.finish()
3838 }
3839 pub fn read_mask(mut self) -> String {
3840 self.path.push(GetObjectRequest::READ_MASK_FIELD.name);
3841 self.finish()
3842 }
3843 }
3844 impl GetObjectResponse {
3845 pub const OBJECT_FIELD: &'static MessageField = &MessageField {
3846 name: "object",
3847 json_name: "object",
3848 number: 1i32,
3849 message_fields: Some(Object::FIELDS),
3850 };
3851 }
3852 impl MessageFields for GetObjectResponse {
3853 const FIELDS: &'static [&'static MessageField] = &[Self::OBJECT_FIELD];
3854 }
3855 impl GetObjectResponse {
3856 pub fn path_builder() -> GetObjectResponseFieldPathBuilder {
3857 GetObjectResponseFieldPathBuilder::new()
3858 }
3859 }
3860 pub struct GetObjectResponseFieldPathBuilder {
3861 path: Vec<&'static str>,
3862 }
3863 impl GetObjectResponseFieldPathBuilder {
3864 #[allow(clippy::new_without_default)]
3865 pub fn new() -> Self {
3866 Self { path: Default::default() }
3867 }
3868 #[doc(hidden)]
3869 pub fn new_with_base(base: Vec<&'static str>) -> Self {
3870 Self { path: base }
3871 }
3872 pub fn finish(self) -> String {
3873 self.path.join(".")
3874 }
3875 pub fn object(mut self) -> ObjectFieldPathBuilder {
3876 self.path.push(GetObjectResponse::OBJECT_FIELD.name);
3877 ObjectFieldPathBuilder::new_with_base(self.path)
3878 }
3879 }
3880 impl BatchGetObjectsRequest {
3881 pub const REQUESTS_FIELD: &'static MessageField = &MessageField {
3882 name: "requests",
3883 json_name: "requests",
3884 number: 1i32,
3885 message_fields: Some(GetObjectRequest::FIELDS),
3886 };
3887 pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
3888 name: "read_mask",
3889 json_name: "readMask",
3890 number: 2i32,
3891 message_fields: None,
3892 };
3893 }
3894 impl MessageFields for BatchGetObjectsRequest {
3895 const FIELDS: &'static [&'static MessageField] = &[
3896 Self::REQUESTS_FIELD,
3897 Self::READ_MASK_FIELD,
3898 ];
3899 }
3900 impl BatchGetObjectsRequest {
3901 pub fn path_builder() -> BatchGetObjectsRequestFieldPathBuilder {
3902 BatchGetObjectsRequestFieldPathBuilder::new()
3903 }
3904 }
3905 pub struct BatchGetObjectsRequestFieldPathBuilder {
3906 path: Vec<&'static str>,
3907 }
3908 impl BatchGetObjectsRequestFieldPathBuilder {
3909 #[allow(clippy::new_without_default)]
3910 pub fn new() -> Self {
3911 Self { path: Default::default() }
3912 }
3913 #[doc(hidden)]
3914 pub fn new_with_base(base: Vec<&'static str>) -> Self {
3915 Self { path: base }
3916 }
3917 pub fn finish(self) -> String {
3918 self.path.join(".")
3919 }
3920 pub fn requests(mut self) -> GetObjectRequestFieldPathBuilder {
3921 self.path.push(BatchGetObjectsRequest::REQUESTS_FIELD.name);
3922 GetObjectRequestFieldPathBuilder::new_with_base(self.path)
3923 }
3924 pub fn read_mask(mut self) -> String {
3925 self.path.push(BatchGetObjectsRequest::READ_MASK_FIELD.name);
3926 self.finish()
3927 }
3928 }
3929 impl BatchGetObjectsResponse {
3930 pub const OBJECTS_FIELD: &'static MessageField = &MessageField {
3931 name: "objects",
3932 json_name: "objects",
3933 number: 1i32,
3934 message_fields: Some(GetObjectResult::FIELDS),
3935 };
3936 }
3937 impl MessageFields for BatchGetObjectsResponse {
3938 const FIELDS: &'static [&'static MessageField] = &[Self::OBJECTS_FIELD];
3939 }
3940 impl BatchGetObjectsResponse {
3941 pub fn path_builder() -> BatchGetObjectsResponseFieldPathBuilder {
3942 BatchGetObjectsResponseFieldPathBuilder::new()
3943 }
3944 }
3945 pub struct BatchGetObjectsResponseFieldPathBuilder {
3946 path: Vec<&'static str>,
3947 }
3948 impl BatchGetObjectsResponseFieldPathBuilder {
3949 #[allow(clippy::new_without_default)]
3950 pub fn new() -> Self {
3951 Self { path: Default::default() }
3952 }
3953 #[doc(hidden)]
3954 pub fn new_with_base(base: Vec<&'static str>) -> Self {
3955 Self { path: base }
3956 }
3957 pub fn finish(self) -> String {
3958 self.path.join(".")
3959 }
3960 pub fn objects(mut self) -> GetObjectResultFieldPathBuilder {
3961 self.path.push(BatchGetObjectsResponse::OBJECTS_FIELD.name);
3962 GetObjectResultFieldPathBuilder::new_with_base(self.path)
3963 }
3964 }
3965 impl GetObjectResult {
3966 pub const OBJECT_FIELD: &'static MessageField = &MessageField {
3967 name: "object",
3968 json_name: "object",
3969 number: 1i32,
3970 message_fields: Some(Object::FIELDS),
3971 };
3972 pub const ERROR_FIELD: &'static MessageField = &MessageField {
3973 name: "error",
3974 json_name: "error",
3975 number: 2i32,
3976 message_fields: None,
3977 };
3978 }
3979 impl MessageFields for GetObjectResult {
3980 const FIELDS: &'static [&'static MessageField] = &[
3981 Self::OBJECT_FIELD,
3982 Self::ERROR_FIELD,
3983 ];
3984 }
3985 impl GetObjectResult {
3986 pub fn path_builder() -> GetObjectResultFieldPathBuilder {
3987 GetObjectResultFieldPathBuilder::new()
3988 }
3989 }
3990 pub struct GetObjectResultFieldPathBuilder {
3991 path: Vec<&'static str>,
3992 }
3993 impl GetObjectResultFieldPathBuilder {
3994 #[allow(clippy::new_without_default)]
3995 pub fn new() -> Self {
3996 Self { path: Default::default() }
3997 }
3998 #[doc(hidden)]
3999 pub fn new_with_base(base: Vec<&'static str>) -> Self {
4000 Self { path: base }
4001 }
4002 pub fn finish(self) -> String {
4003 self.path.join(".")
4004 }
4005 pub fn object(mut self) -> ObjectFieldPathBuilder {
4006 self.path.push(GetObjectResult::OBJECT_FIELD.name);
4007 ObjectFieldPathBuilder::new_with_base(self.path)
4008 }
4009 pub fn error(mut self) -> String {
4010 self.path.push(GetObjectResult::ERROR_FIELD.name);
4011 self.finish()
4012 }
4013 }
4014 impl GetTransactionRequest {
4015 pub const DIGEST_FIELD: &'static MessageField = &MessageField {
4016 name: "digest",
4017 json_name: "digest",
4018 number: 1i32,
4019 message_fields: None,
4020 };
4021 pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
4022 name: "read_mask",
4023 json_name: "readMask",
4024 number: 2i32,
4025 message_fields: None,
4026 };
4027 }
4028 impl MessageFields for GetTransactionRequest {
4029 const FIELDS: &'static [&'static MessageField] = &[
4030 Self::DIGEST_FIELD,
4031 Self::READ_MASK_FIELD,
4032 ];
4033 }
4034 impl GetTransactionRequest {
4035 pub fn path_builder() -> GetTransactionRequestFieldPathBuilder {
4036 GetTransactionRequestFieldPathBuilder::new()
4037 }
4038 }
4039 pub struct GetTransactionRequestFieldPathBuilder {
4040 path: Vec<&'static str>,
4041 }
4042 impl GetTransactionRequestFieldPathBuilder {
4043 #[allow(clippy::new_without_default)]
4044 pub fn new() -> Self {
4045 Self { path: Default::default() }
4046 }
4047 #[doc(hidden)]
4048 pub fn new_with_base(base: Vec<&'static str>) -> Self {
4049 Self { path: base }
4050 }
4051 pub fn finish(self) -> String {
4052 self.path.join(".")
4053 }
4054 pub fn digest(mut self) -> String {
4055 self.path.push(GetTransactionRequest::DIGEST_FIELD.name);
4056 self.finish()
4057 }
4058 pub fn read_mask(mut self) -> String {
4059 self.path.push(GetTransactionRequest::READ_MASK_FIELD.name);
4060 self.finish()
4061 }
4062 }
4063 impl GetTransactionResponse {
4064 pub const TRANSACTION_FIELD: &'static MessageField = &MessageField {
4065 name: "transaction",
4066 json_name: "transaction",
4067 number: 1i32,
4068 message_fields: Some(ExecutedTransaction::FIELDS),
4069 };
4070 }
4071 impl MessageFields for GetTransactionResponse {
4072 const FIELDS: &'static [&'static MessageField] = &[Self::TRANSACTION_FIELD];
4073 }
4074 impl GetTransactionResponse {
4075 pub fn path_builder() -> GetTransactionResponseFieldPathBuilder {
4076 GetTransactionResponseFieldPathBuilder::new()
4077 }
4078 }
4079 pub struct GetTransactionResponseFieldPathBuilder {
4080 path: Vec<&'static str>,
4081 }
4082 impl GetTransactionResponseFieldPathBuilder {
4083 #[allow(clippy::new_without_default)]
4084 pub fn new() -> Self {
4085 Self { path: Default::default() }
4086 }
4087 #[doc(hidden)]
4088 pub fn new_with_base(base: Vec<&'static str>) -> Self {
4089 Self { path: base }
4090 }
4091 pub fn finish(self) -> String {
4092 self.path.join(".")
4093 }
4094 pub fn transaction(mut self) -> ExecutedTransactionFieldPathBuilder {
4095 self.path.push(GetTransactionResponse::TRANSACTION_FIELD.name);
4096 ExecutedTransactionFieldPathBuilder::new_with_base(self.path)
4097 }
4098 }
4099 impl BatchGetTransactionsRequest {
4100 pub const DIGESTS_FIELD: &'static MessageField = &MessageField {
4101 name: "digests",
4102 json_name: "digests",
4103 number: 1i32,
4104 message_fields: None,
4105 };
4106 pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
4107 name: "read_mask",
4108 json_name: "readMask",
4109 number: 2i32,
4110 message_fields: None,
4111 };
4112 }
4113 impl MessageFields for BatchGetTransactionsRequest {
4114 const FIELDS: &'static [&'static MessageField] = &[
4115 Self::DIGESTS_FIELD,
4116 Self::READ_MASK_FIELD,
4117 ];
4118 }
4119 impl BatchGetTransactionsRequest {
4120 pub fn path_builder() -> BatchGetTransactionsRequestFieldPathBuilder {
4121 BatchGetTransactionsRequestFieldPathBuilder::new()
4122 }
4123 }
4124 pub struct BatchGetTransactionsRequestFieldPathBuilder {
4125 path: Vec<&'static str>,
4126 }
4127 impl BatchGetTransactionsRequestFieldPathBuilder {
4128 #[allow(clippy::new_without_default)]
4129 pub fn new() -> Self {
4130 Self { path: Default::default() }
4131 }
4132 #[doc(hidden)]
4133 pub fn new_with_base(base: Vec<&'static str>) -> Self {
4134 Self { path: base }
4135 }
4136 pub fn finish(self) -> String {
4137 self.path.join(".")
4138 }
4139 pub fn digests(mut self) -> String {
4140 self.path.push(BatchGetTransactionsRequest::DIGESTS_FIELD.name);
4141 self.finish()
4142 }
4143 pub fn read_mask(mut self) -> String {
4144 self.path.push(BatchGetTransactionsRequest::READ_MASK_FIELD.name);
4145 self.finish()
4146 }
4147 }
4148 impl BatchGetTransactionsResponse {
4149 pub const TRANSACTIONS_FIELD: &'static MessageField = &MessageField {
4150 name: "transactions",
4151 json_name: "transactions",
4152 number: 1i32,
4153 message_fields: Some(GetTransactionResult::FIELDS),
4154 };
4155 }
4156 impl MessageFields for BatchGetTransactionsResponse {
4157 const FIELDS: &'static [&'static MessageField] = &[Self::TRANSACTIONS_FIELD];
4158 }
4159 impl BatchGetTransactionsResponse {
4160 pub fn path_builder() -> BatchGetTransactionsResponseFieldPathBuilder {
4161 BatchGetTransactionsResponseFieldPathBuilder::new()
4162 }
4163 }
4164 pub struct BatchGetTransactionsResponseFieldPathBuilder {
4165 path: Vec<&'static str>,
4166 }
4167 impl BatchGetTransactionsResponseFieldPathBuilder {
4168 #[allow(clippy::new_without_default)]
4169 pub fn new() -> Self {
4170 Self { path: Default::default() }
4171 }
4172 #[doc(hidden)]
4173 pub fn new_with_base(base: Vec<&'static str>) -> Self {
4174 Self { path: base }
4175 }
4176 pub fn finish(self) -> String {
4177 self.path.join(".")
4178 }
4179 pub fn transactions(mut self) -> GetTransactionResultFieldPathBuilder {
4180 self.path.push(BatchGetTransactionsResponse::TRANSACTIONS_FIELD.name);
4181 GetTransactionResultFieldPathBuilder::new_with_base(self.path)
4182 }
4183 }
4184 impl GetTransactionResult {
4185 pub const TRANSACTION_FIELD: &'static MessageField = &MessageField {
4186 name: "transaction",
4187 json_name: "transaction",
4188 number: 1i32,
4189 message_fields: Some(ExecutedTransaction::FIELDS),
4190 };
4191 pub const ERROR_FIELD: &'static MessageField = &MessageField {
4192 name: "error",
4193 json_name: "error",
4194 number: 2i32,
4195 message_fields: None,
4196 };
4197 }
4198 impl MessageFields for GetTransactionResult {
4199 const FIELDS: &'static [&'static MessageField] = &[
4200 Self::TRANSACTION_FIELD,
4201 Self::ERROR_FIELD,
4202 ];
4203 }
4204 impl GetTransactionResult {
4205 pub fn path_builder() -> GetTransactionResultFieldPathBuilder {
4206 GetTransactionResultFieldPathBuilder::new()
4207 }
4208 }
4209 pub struct GetTransactionResultFieldPathBuilder {
4210 path: Vec<&'static str>,
4211 }
4212 impl GetTransactionResultFieldPathBuilder {
4213 #[allow(clippy::new_without_default)]
4214 pub fn new() -> Self {
4215 Self { path: Default::default() }
4216 }
4217 #[doc(hidden)]
4218 pub fn new_with_base(base: Vec<&'static str>) -> Self {
4219 Self { path: base }
4220 }
4221 pub fn finish(self) -> String {
4222 self.path.join(".")
4223 }
4224 pub fn transaction(mut self) -> ExecutedTransactionFieldPathBuilder {
4225 self.path.push(GetTransactionResult::TRANSACTION_FIELD.name);
4226 ExecutedTransactionFieldPathBuilder::new_with_base(self.path)
4227 }
4228 pub fn error(mut self) -> String {
4229 self.path.push(GetTransactionResult::ERROR_FIELD.name);
4230 self.finish()
4231 }
4232 }
4233 impl GetCheckpointRequest {
4234 pub const SEQUENCE_NUMBER_FIELD: &'static MessageField = &MessageField {
4235 name: "sequence_number",
4236 json_name: "sequenceNumber",
4237 number: 1i32,
4238 message_fields: None,
4239 };
4240 pub const DIGEST_FIELD: &'static MessageField = &MessageField {
4241 name: "digest",
4242 json_name: "digest",
4243 number: 2i32,
4244 message_fields: None,
4245 };
4246 pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
4247 name: "read_mask",
4248 json_name: "readMask",
4249 number: 3i32,
4250 message_fields: None,
4251 };
4252 }
4253 impl MessageFields for GetCheckpointRequest {
4254 const FIELDS: &'static [&'static MessageField] = &[
4255 Self::SEQUENCE_NUMBER_FIELD,
4256 Self::DIGEST_FIELD,
4257 Self::READ_MASK_FIELD,
4258 ];
4259 }
4260 impl GetCheckpointRequest {
4261 pub fn path_builder() -> GetCheckpointRequestFieldPathBuilder {
4262 GetCheckpointRequestFieldPathBuilder::new()
4263 }
4264 }
4265 pub struct GetCheckpointRequestFieldPathBuilder {
4266 path: Vec<&'static str>,
4267 }
4268 impl GetCheckpointRequestFieldPathBuilder {
4269 #[allow(clippy::new_without_default)]
4270 pub fn new() -> Self {
4271 Self { path: Default::default() }
4272 }
4273 #[doc(hidden)]
4274 pub fn new_with_base(base: Vec<&'static str>) -> Self {
4275 Self { path: base }
4276 }
4277 pub fn finish(self) -> String {
4278 self.path.join(".")
4279 }
4280 pub fn sequence_number(mut self) -> String {
4281 self.path.push(GetCheckpointRequest::SEQUENCE_NUMBER_FIELD.name);
4282 self.finish()
4283 }
4284 pub fn digest(mut self) -> String {
4285 self.path.push(GetCheckpointRequest::DIGEST_FIELD.name);
4286 self.finish()
4287 }
4288 pub fn read_mask(mut self) -> String {
4289 self.path.push(GetCheckpointRequest::READ_MASK_FIELD.name);
4290 self.finish()
4291 }
4292 }
4293 impl GetCheckpointResponse {
4294 pub const CHECKPOINT_FIELD: &'static MessageField = &MessageField {
4295 name: "checkpoint",
4296 json_name: "checkpoint",
4297 number: 1i32,
4298 message_fields: Some(Checkpoint::FIELDS),
4299 };
4300 }
4301 impl MessageFields for GetCheckpointResponse {
4302 const FIELDS: &'static [&'static MessageField] = &[Self::CHECKPOINT_FIELD];
4303 }
4304 impl GetCheckpointResponse {
4305 pub fn path_builder() -> GetCheckpointResponseFieldPathBuilder {
4306 GetCheckpointResponseFieldPathBuilder::new()
4307 }
4308 }
4309 pub struct GetCheckpointResponseFieldPathBuilder {
4310 path: Vec<&'static str>,
4311 }
4312 impl GetCheckpointResponseFieldPathBuilder {
4313 #[allow(clippy::new_without_default)]
4314 pub fn new() -> Self {
4315 Self { path: Default::default() }
4316 }
4317 #[doc(hidden)]
4318 pub fn new_with_base(base: Vec<&'static str>) -> Self {
4319 Self { path: base }
4320 }
4321 pub fn finish(self) -> String {
4322 self.path.join(".")
4323 }
4324 pub fn checkpoint(mut self) -> CheckpointFieldPathBuilder {
4325 self.path.push(GetCheckpointResponse::CHECKPOINT_FIELD.name);
4326 CheckpointFieldPathBuilder::new_with_base(self.path)
4327 }
4328 }
4329 impl GetEpochRequest {
4330 pub const EPOCH_FIELD: &'static MessageField = &MessageField {
4331 name: "epoch",
4332 json_name: "epoch",
4333 number: 1i32,
4334 message_fields: None,
4335 };
4336 pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
4337 name: "read_mask",
4338 json_name: "readMask",
4339 number: 2i32,
4340 message_fields: None,
4341 };
4342 }
4343 impl MessageFields for GetEpochRequest {
4344 const FIELDS: &'static [&'static MessageField] = &[
4345 Self::EPOCH_FIELD,
4346 Self::READ_MASK_FIELD,
4347 ];
4348 }
4349 impl GetEpochRequest {
4350 pub fn path_builder() -> GetEpochRequestFieldPathBuilder {
4351 GetEpochRequestFieldPathBuilder::new()
4352 }
4353 }
4354 pub struct GetEpochRequestFieldPathBuilder {
4355 path: Vec<&'static str>,
4356 }
4357 impl GetEpochRequestFieldPathBuilder {
4358 #[allow(clippy::new_without_default)]
4359 pub fn new() -> Self {
4360 Self { path: Default::default() }
4361 }
4362 #[doc(hidden)]
4363 pub fn new_with_base(base: Vec<&'static str>) -> Self {
4364 Self { path: base }
4365 }
4366 pub fn finish(self) -> String {
4367 self.path.join(".")
4368 }
4369 pub fn epoch(mut self) -> String {
4370 self.path.push(GetEpochRequest::EPOCH_FIELD.name);
4371 self.finish()
4372 }
4373 pub fn read_mask(mut self) -> String {
4374 self.path.push(GetEpochRequest::READ_MASK_FIELD.name);
4375 self.finish()
4376 }
4377 }
4378 impl GetEpochResponse {
4379 pub const EPOCH_FIELD: &'static MessageField = &MessageField {
4380 name: "epoch",
4381 json_name: "epoch",
4382 number: 1i32,
4383 message_fields: Some(Epoch::FIELDS),
4384 };
4385 }
4386 impl MessageFields for GetEpochResponse {
4387 const FIELDS: &'static [&'static MessageField] = &[Self::EPOCH_FIELD];
4388 }
4389 impl GetEpochResponse {
4390 pub fn path_builder() -> GetEpochResponseFieldPathBuilder {
4391 GetEpochResponseFieldPathBuilder::new()
4392 }
4393 }
4394 pub struct GetEpochResponseFieldPathBuilder {
4395 path: Vec<&'static str>,
4396 }
4397 impl GetEpochResponseFieldPathBuilder {
4398 #[allow(clippy::new_without_default)]
4399 pub fn new() -> Self {
4400 Self { path: Default::default() }
4401 }
4402 #[doc(hidden)]
4403 pub fn new_with_base(base: Vec<&'static str>) -> Self {
4404 Self { path: base }
4405 }
4406 pub fn finish(self) -> String {
4407 self.path.join(".")
4408 }
4409 pub fn epoch(mut self) -> EpochFieldPathBuilder {
4410 self.path.push(GetEpochResponse::EPOCH_FIELD.name);
4411 EpochFieldPathBuilder::new_with_base(self.path)
4412 }
4413 }
4414 impl ListCheckpointsRequest {
4415 pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
4416 name: "read_mask",
4417 json_name: "readMask",
4418 number: 1i32,
4419 message_fields: None,
4420 };
4421 pub const START_CHECKPOINT_FIELD: &'static MessageField = &MessageField {
4422 name: "start_checkpoint",
4423 json_name: "startCheckpoint",
4424 number: 2i32,
4425 message_fields: None,
4426 };
4427 pub const END_CHECKPOINT_FIELD: &'static MessageField = &MessageField {
4428 name: "end_checkpoint",
4429 json_name: "endCheckpoint",
4430 number: 3i32,
4431 message_fields: None,
4432 };
4433 pub const FILTER_FIELD: &'static MessageField = &MessageField {
4434 name: "filter",
4435 json_name: "filter",
4436 number: 4i32,
4437 message_fields: Some(TransactionFilter::FIELDS),
4438 };
4439 pub const OPTIONS_FIELD: &'static MessageField = &MessageField {
4440 name: "options",
4441 json_name: "options",
4442 number: 5i32,
4443 message_fields: Some(QueryOptions::FIELDS),
4444 };
4445 }
4446 impl MessageFields for ListCheckpointsRequest {
4447 const FIELDS: &'static [&'static MessageField] = &[
4448 Self::READ_MASK_FIELD,
4449 Self::START_CHECKPOINT_FIELD,
4450 Self::END_CHECKPOINT_FIELD,
4451 Self::FILTER_FIELD,
4452 Self::OPTIONS_FIELD,
4453 ];
4454 }
4455 impl ListCheckpointsRequest {
4456 pub fn path_builder() -> ListCheckpointsRequestFieldPathBuilder {
4457 ListCheckpointsRequestFieldPathBuilder::new()
4458 }
4459 }
4460 pub struct ListCheckpointsRequestFieldPathBuilder {
4461 path: Vec<&'static str>,
4462 }
4463 impl ListCheckpointsRequestFieldPathBuilder {
4464 #[allow(clippy::new_without_default)]
4465 pub fn new() -> Self {
4466 Self { path: Default::default() }
4467 }
4468 #[doc(hidden)]
4469 pub fn new_with_base(base: Vec<&'static str>) -> Self {
4470 Self { path: base }
4471 }
4472 pub fn finish(self) -> String {
4473 self.path.join(".")
4474 }
4475 pub fn read_mask(mut self) -> String {
4476 self.path.push(ListCheckpointsRequest::READ_MASK_FIELD.name);
4477 self.finish()
4478 }
4479 pub fn start_checkpoint(mut self) -> String {
4480 self.path.push(ListCheckpointsRequest::START_CHECKPOINT_FIELD.name);
4481 self.finish()
4482 }
4483 pub fn end_checkpoint(mut self) -> String {
4484 self.path.push(ListCheckpointsRequest::END_CHECKPOINT_FIELD.name);
4485 self.finish()
4486 }
4487 pub fn filter(mut self) -> TransactionFilterFieldPathBuilder {
4488 self.path.push(ListCheckpointsRequest::FILTER_FIELD.name);
4489 TransactionFilterFieldPathBuilder::new_with_base(self.path)
4490 }
4491 pub fn options(mut self) -> QueryOptionsFieldPathBuilder {
4492 self.path.push(ListCheckpointsRequest::OPTIONS_FIELD.name);
4493 QueryOptionsFieldPathBuilder::new_with_base(self.path)
4494 }
4495 }
4496 impl ListCheckpointsResponse {
4497 pub const CHECKPOINT_FIELD: &'static MessageField = &MessageField {
4498 name: "checkpoint",
4499 json_name: "checkpoint",
4500 number: 1i32,
4501 message_fields: Some(Checkpoint::FIELDS),
4502 };
4503 pub const WATERMARK_FIELD: &'static MessageField = &MessageField {
4504 name: "watermark",
4505 json_name: "watermark",
4506 number: 2i32,
4507 message_fields: Some(Watermark::FIELDS),
4508 };
4509 pub const END_FIELD: &'static MessageField = &MessageField {
4510 name: "end",
4511 json_name: "end",
4512 number: 3i32,
4513 message_fields: Some(QueryEnd::FIELDS),
4514 };
4515 }
4516 impl MessageFields for ListCheckpointsResponse {
4517 const FIELDS: &'static [&'static MessageField] = &[
4518 Self::CHECKPOINT_FIELD,
4519 Self::WATERMARK_FIELD,
4520 Self::END_FIELD,
4521 ];
4522 }
4523 impl ListCheckpointsResponse {
4524 pub fn path_builder() -> ListCheckpointsResponseFieldPathBuilder {
4525 ListCheckpointsResponseFieldPathBuilder::new()
4526 }
4527 }
4528 pub struct ListCheckpointsResponseFieldPathBuilder {
4529 path: Vec<&'static str>,
4530 }
4531 impl ListCheckpointsResponseFieldPathBuilder {
4532 #[allow(clippy::new_without_default)]
4533 pub fn new() -> Self {
4534 Self { path: Default::default() }
4535 }
4536 #[doc(hidden)]
4537 pub fn new_with_base(base: Vec<&'static str>) -> Self {
4538 Self { path: base }
4539 }
4540 pub fn finish(self) -> String {
4541 self.path.join(".")
4542 }
4543 pub fn checkpoint(mut self) -> CheckpointFieldPathBuilder {
4544 self.path.push(ListCheckpointsResponse::CHECKPOINT_FIELD.name);
4545 CheckpointFieldPathBuilder::new_with_base(self.path)
4546 }
4547 pub fn watermark(mut self) -> WatermarkFieldPathBuilder {
4548 self.path.push(ListCheckpointsResponse::WATERMARK_FIELD.name);
4549 WatermarkFieldPathBuilder::new_with_base(self.path)
4550 }
4551 pub fn end(mut self) -> QueryEndFieldPathBuilder {
4552 self.path.push(ListCheckpointsResponse::END_FIELD.name);
4553 QueryEndFieldPathBuilder::new_with_base(self.path)
4554 }
4555 }
4556 impl ListTransactionsRequest {
4557 pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
4558 name: "read_mask",
4559 json_name: "readMask",
4560 number: 1i32,
4561 message_fields: None,
4562 };
4563 pub const START_CHECKPOINT_FIELD: &'static MessageField = &MessageField {
4564 name: "start_checkpoint",
4565 json_name: "startCheckpoint",
4566 number: 2i32,
4567 message_fields: None,
4568 };
4569 pub const END_CHECKPOINT_FIELD: &'static MessageField = &MessageField {
4570 name: "end_checkpoint",
4571 json_name: "endCheckpoint",
4572 number: 3i32,
4573 message_fields: None,
4574 };
4575 pub const FILTER_FIELD: &'static MessageField = &MessageField {
4576 name: "filter",
4577 json_name: "filter",
4578 number: 4i32,
4579 message_fields: Some(TransactionFilter::FIELDS),
4580 };
4581 pub const OPTIONS_FIELD: &'static MessageField = &MessageField {
4582 name: "options",
4583 json_name: "options",
4584 number: 5i32,
4585 message_fields: Some(QueryOptions::FIELDS),
4586 };
4587 }
4588 impl MessageFields for ListTransactionsRequest {
4589 const FIELDS: &'static [&'static MessageField] = &[
4590 Self::READ_MASK_FIELD,
4591 Self::START_CHECKPOINT_FIELD,
4592 Self::END_CHECKPOINT_FIELD,
4593 Self::FILTER_FIELD,
4594 Self::OPTIONS_FIELD,
4595 ];
4596 }
4597 impl ListTransactionsRequest {
4598 pub fn path_builder() -> ListTransactionsRequestFieldPathBuilder {
4599 ListTransactionsRequestFieldPathBuilder::new()
4600 }
4601 }
4602 pub struct ListTransactionsRequestFieldPathBuilder {
4603 path: Vec<&'static str>,
4604 }
4605 impl ListTransactionsRequestFieldPathBuilder {
4606 #[allow(clippy::new_without_default)]
4607 pub fn new() -> Self {
4608 Self { path: Default::default() }
4609 }
4610 #[doc(hidden)]
4611 pub fn new_with_base(base: Vec<&'static str>) -> Self {
4612 Self { path: base }
4613 }
4614 pub fn finish(self) -> String {
4615 self.path.join(".")
4616 }
4617 pub fn read_mask(mut self) -> String {
4618 self.path.push(ListTransactionsRequest::READ_MASK_FIELD.name);
4619 self.finish()
4620 }
4621 pub fn start_checkpoint(mut self) -> String {
4622 self.path.push(ListTransactionsRequest::START_CHECKPOINT_FIELD.name);
4623 self.finish()
4624 }
4625 pub fn end_checkpoint(mut self) -> String {
4626 self.path.push(ListTransactionsRequest::END_CHECKPOINT_FIELD.name);
4627 self.finish()
4628 }
4629 pub fn filter(mut self) -> TransactionFilterFieldPathBuilder {
4630 self.path.push(ListTransactionsRequest::FILTER_FIELD.name);
4631 TransactionFilterFieldPathBuilder::new_with_base(self.path)
4632 }
4633 pub fn options(mut self) -> QueryOptionsFieldPathBuilder {
4634 self.path.push(ListTransactionsRequest::OPTIONS_FIELD.name);
4635 QueryOptionsFieldPathBuilder::new_with_base(self.path)
4636 }
4637 }
4638 impl ListTransactionsResponse {
4639 pub const TRANSACTION_FIELD: &'static MessageField = &MessageField {
4640 name: "transaction",
4641 json_name: "transaction",
4642 number: 1i32,
4643 message_fields: Some(ExecutedTransaction::FIELDS),
4644 };
4645 pub const WATERMARK_FIELD: &'static MessageField = &MessageField {
4646 name: "watermark",
4647 json_name: "watermark",
4648 number: 2i32,
4649 message_fields: Some(Watermark::FIELDS),
4650 };
4651 pub const END_FIELD: &'static MessageField = &MessageField {
4652 name: "end",
4653 json_name: "end",
4654 number: 3i32,
4655 message_fields: Some(QueryEnd::FIELDS),
4656 };
4657 }
4658 impl MessageFields for ListTransactionsResponse {
4659 const FIELDS: &'static [&'static MessageField] = &[
4660 Self::TRANSACTION_FIELD,
4661 Self::WATERMARK_FIELD,
4662 Self::END_FIELD,
4663 ];
4664 }
4665 impl ListTransactionsResponse {
4666 pub fn path_builder() -> ListTransactionsResponseFieldPathBuilder {
4667 ListTransactionsResponseFieldPathBuilder::new()
4668 }
4669 }
4670 pub struct ListTransactionsResponseFieldPathBuilder {
4671 path: Vec<&'static str>,
4672 }
4673 impl ListTransactionsResponseFieldPathBuilder {
4674 #[allow(clippy::new_without_default)]
4675 pub fn new() -> Self {
4676 Self { path: Default::default() }
4677 }
4678 #[doc(hidden)]
4679 pub fn new_with_base(base: Vec<&'static str>) -> Self {
4680 Self { path: base }
4681 }
4682 pub fn finish(self) -> String {
4683 self.path.join(".")
4684 }
4685 pub fn transaction(mut self) -> ExecutedTransactionFieldPathBuilder {
4686 self.path.push(ListTransactionsResponse::TRANSACTION_FIELD.name);
4687 ExecutedTransactionFieldPathBuilder::new_with_base(self.path)
4688 }
4689 pub fn watermark(mut self) -> WatermarkFieldPathBuilder {
4690 self.path.push(ListTransactionsResponse::WATERMARK_FIELD.name);
4691 WatermarkFieldPathBuilder::new_with_base(self.path)
4692 }
4693 pub fn end(mut self) -> QueryEndFieldPathBuilder {
4694 self.path.push(ListTransactionsResponse::END_FIELD.name);
4695 QueryEndFieldPathBuilder::new_with_base(self.path)
4696 }
4697 }
4698 impl ListEventsRequest {
4699 pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
4700 name: "read_mask",
4701 json_name: "readMask",
4702 number: 1i32,
4703 message_fields: None,
4704 };
4705 pub const START_CHECKPOINT_FIELD: &'static MessageField = &MessageField {
4706 name: "start_checkpoint",
4707 json_name: "startCheckpoint",
4708 number: 2i32,
4709 message_fields: None,
4710 };
4711 pub const END_CHECKPOINT_FIELD: &'static MessageField = &MessageField {
4712 name: "end_checkpoint",
4713 json_name: "endCheckpoint",
4714 number: 3i32,
4715 message_fields: None,
4716 };
4717 pub const FILTER_FIELD: &'static MessageField = &MessageField {
4718 name: "filter",
4719 json_name: "filter",
4720 number: 4i32,
4721 message_fields: Some(EventFilter::FIELDS),
4722 };
4723 pub const OPTIONS_FIELD: &'static MessageField = &MessageField {
4724 name: "options",
4725 json_name: "options",
4726 number: 5i32,
4727 message_fields: Some(QueryOptions::FIELDS),
4728 };
4729 }
4730 impl MessageFields for ListEventsRequest {
4731 const FIELDS: &'static [&'static MessageField] = &[
4732 Self::READ_MASK_FIELD,
4733 Self::START_CHECKPOINT_FIELD,
4734 Self::END_CHECKPOINT_FIELD,
4735 Self::FILTER_FIELD,
4736 Self::OPTIONS_FIELD,
4737 ];
4738 }
4739 impl ListEventsRequest {
4740 pub fn path_builder() -> ListEventsRequestFieldPathBuilder {
4741 ListEventsRequestFieldPathBuilder::new()
4742 }
4743 }
4744 pub struct ListEventsRequestFieldPathBuilder {
4745 path: Vec<&'static str>,
4746 }
4747 impl ListEventsRequestFieldPathBuilder {
4748 #[allow(clippy::new_without_default)]
4749 pub fn new() -> Self {
4750 Self { path: Default::default() }
4751 }
4752 #[doc(hidden)]
4753 pub fn new_with_base(base: Vec<&'static str>) -> Self {
4754 Self { path: base }
4755 }
4756 pub fn finish(self) -> String {
4757 self.path.join(".")
4758 }
4759 pub fn read_mask(mut self) -> String {
4760 self.path.push(ListEventsRequest::READ_MASK_FIELD.name);
4761 self.finish()
4762 }
4763 pub fn start_checkpoint(mut self) -> String {
4764 self.path.push(ListEventsRequest::START_CHECKPOINT_FIELD.name);
4765 self.finish()
4766 }
4767 pub fn end_checkpoint(mut self) -> String {
4768 self.path.push(ListEventsRequest::END_CHECKPOINT_FIELD.name);
4769 self.finish()
4770 }
4771 pub fn filter(mut self) -> EventFilterFieldPathBuilder {
4772 self.path.push(ListEventsRequest::FILTER_FIELD.name);
4773 EventFilterFieldPathBuilder::new_with_base(self.path)
4774 }
4775 pub fn options(mut self) -> QueryOptionsFieldPathBuilder {
4776 self.path.push(ListEventsRequest::OPTIONS_FIELD.name);
4777 QueryOptionsFieldPathBuilder::new_with_base(self.path)
4778 }
4779 }
4780 impl ListEventsResponse {
4781 pub const EVENT_FIELD: &'static MessageField = &MessageField {
4782 name: "event",
4783 json_name: "event",
4784 number: 1i32,
4785 message_fields: Some(Event::FIELDS),
4786 };
4787 pub const WATERMARK_FIELD: &'static MessageField = &MessageField {
4788 name: "watermark",
4789 json_name: "watermark",
4790 number: 2i32,
4791 message_fields: Some(Watermark::FIELDS),
4792 };
4793 pub const END_FIELD: &'static MessageField = &MessageField {
4794 name: "end",
4795 json_name: "end",
4796 number: 3i32,
4797 message_fields: Some(QueryEnd::FIELDS),
4798 };
4799 }
4800 impl MessageFields for ListEventsResponse {
4801 const FIELDS: &'static [&'static MessageField] = &[
4802 Self::EVENT_FIELD,
4803 Self::WATERMARK_FIELD,
4804 Self::END_FIELD,
4805 ];
4806 }
4807 impl ListEventsResponse {
4808 pub fn path_builder() -> ListEventsResponseFieldPathBuilder {
4809 ListEventsResponseFieldPathBuilder::new()
4810 }
4811 }
4812 pub struct ListEventsResponseFieldPathBuilder {
4813 path: Vec<&'static str>,
4814 }
4815 impl ListEventsResponseFieldPathBuilder {
4816 #[allow(clippy::new_without_default)]
4817 pub fn new() -> Self {
4818 Self { path: Default::default() }
4819 }
4820 #[doc(hidden)]
4821 pub fn new_with_base(base: Vec<&'static str>) -> Self {
4822 Self { path: base }
4823 }
4824 pub fn finish(self) -> String {
4825 self.path.join(".")
4826 }
4827 pub fn event(mut self) -> EventFieldPathBuilder {
4828 self.path.push(ListEventsResponse::EVENT_FIELD.name);
4829 EventFieldPathBuilder::new_with_base(self.path)
4830 }
4831 pub fn watermark(mut self) -> WatermarkFieldPathBuilder {
4832 self.path.push(ListEventsResponse::WATERMARK_FIELD.name);
4833 WatermarkFieldPathBuilder::new_with_base(self.path)
4834 }
4835 pub fn end(mut self) -> QueryEndFieldPathBuilder {
4836 self.path.push(ListEventsResponse::END_FIELD.name);
4837 QueryEndFieldPathBuilder::new_with_base(self.path)
4838 }
4839 }
4840 impl Package {
4841 pub const STORAGE_ID_FIELD: &'static MessageField = &MessageField {
4842 name: "storage_id",
4843 json_name: "storageId",
4844 number: 1i32,
4845 message_fields: None,
4846 };
4847 pub const ORIGINAL_ID_FIELD: &'static MessageField = &MessageField {
4848 name: "original_id",
4849 json_name: "originalId",
4850 number: 2i32,
4851 message_fields: None,
4852 };
4853 pub const VERSION_FIELD: &'static MessageField = &MessageField {
4854 name: "version",
4855 json_name: "version",
4856 number: 3i32,
4857 message_fields: None,
4858 };
4859 pub const MODULES_FIELD: &'static MessageField = &MessageField {
4860 name: "modules",
4861 json_name: "modules",
4862 number: 4i32,
4863 message_fields: Some(Module::FIELDS),
4864 };
4865 pub const TYPE_ORIGINS_FIELD: &'static MessageField = &MessageField {
4866 name: "type_origins",
4867 json_name: "typeOrigins",
4868 number: 5i32,
4869 message_fields: Some(TypeOrigin::FIELDS),
4870 };
4871 pub const LINKAGE_FIELD: &'static MessageField = &MessageField {
4872 name: "linkage",
4873 json_name: "linkage",
4874 number: 6i32,
4875 message_fields: Some(Linkage::FIELDS),
4876 };
4877 }
4878 impl MessageFields for Package {
4879 const FIELDS: &'static [&'static MessageField] = &[
4880 Self::STORAGE_ID_FIELD,
4881 Self::ORIGINAL_ID_FIELD,
4882 Self::VERSION_FIELD,
4883 Self::MODULES_FIELD,
4884 Self::TYPE_ORIGINS_FIELD,
4885 Self::LINKAGE_FIELD,
4886 ];
4887 }
4888 impl Package {
4889 pub fn path_builder() -> PackageFieldPathBuilder {
4890 PackageFieldPathBuilder::new()
4891 }
4892 }
4893 pub struct PackageFieldPathBuilder {
4894 path: Vec<&'static str>,
4895 }
4896 impl PackageFieldPathBuilder {
4897 #[allow(clippy::new_without_default)]
4898 pub fn new() -> Self {
4899 Self { path: Default::default() }
4900 }
4901 #[doc(hidden)]
4902 pub fn new_with_base(base: Vec<&'static str>) -> Self {
4903 Self { path: base }
4904 }
4905 pub fn finish(self) -> String {
4906 self.path.join(".")
4907 }
4908 pub fn storage_id(mut self) -> String {
4909 self.path.push(Package::STORAGE_ID_FIELD.name);
4910 self.finish()
4911 }
4912 pub fn original_id(mut self) -> String {
4913 self.path.push(Package::ORIGINAL_ID_FIELD.name);
4914 self.finish()
4915 }
4916 pub fn version(mut self) -> String {
4917 self.path.push(Package::VERSION_FIELD.name);
4918 self.finish()
4919 }
4920 pub fn modules(mut self) -> ModuleFieldPathBuilder {
4921 self.path.push(Package::MODULES_FIELD.name);
4922 ModuleFieldPathBuilder::new_with_base(self.path)
4923 }
4924 pub fn type_origins(mut self) -> TypeOriginFieldPathBuilder {
4925 self.path.push(Package::TYPE_ORIGINS_FIELD.name);
4926 TypeOriginFieldPathBuilder::new_with_base(self.path)
4927 }
4928 pub fn linkage(mut self) -> LinkageFieldPathBuilder {
4929 self.path.push(Package::LINKAGE_FIELD.name);
4930 LinkageFieldPathBuilder::new_with_base(self.path)
4931 }
4932 }
4933 impl Module {
4934 pub const NAME_FIELD: &'static MessageField = &MessageField {
4935 name: "name",
4936 json_name: "name",
4937 number: 1i32,
4938 message_fields: None,
4939 };
4940 pub const CONTENTS_FIELD: &'static MessageField = &MessageField {
4941 name: "contents",
4942 json_name: "contents",
4943 number: 2i32,
4944 message_fields: None,
4945 };
4946 pub const DATATYPES_FIELD: &'static MessageField = &MessageField {
4947 name: "datatypes",
4948 json_name: "datatypes",
4949 number: 3i32,
4950 message_fields: Some(DatatypeDescriptor::FIELDS),
4951 };
4952 pub const FUNCTIONS_FIELD: &'static MessageField = &MessageField {
4953 name: "functions",
4954 json_name: "functions",
4955 number: 4i32,
4956 message_fields: Some(FunctionDescriptor::FIELDS),
4957 };
4958 }
4959 impl MessageFields for Module {
4960 const FIELDS: &'static [&'static MessageField] = &[
4961 Self::NAME_FIELD,
4962 Self::CONTENTS_FIELD,
4963 Self::DATATYPES_FIELD,
4964 Self::FUNCTIONS_FIELD,
4965 ];
4966 }
4967 impl Module {
4968 pub fn path_builder() -> ModuleFieldPathBuilder {
4969 ModuleFieldPathBuilder::new()
4970 }
4971 }
4972 pub struct ModuleFieldPathBuilder {
4973 path: Vec<&'static str>,
4974 }
4975 impl ModuleFieldPathBuilder {
4976 #[allow(clippy::new_without_default)]
4977 pub fn new() -> Self {
4978 Self { path: Default::default() }
4979 }
4980 #[doc(hidden)]
4981 pub fn new_with_base(base: Vec<&'static str>) -> Self {
4982 Self { path: base }
4983 }
4984 pub fn finish(self) -> String {
4985 self.path.join(".")
4986 }
4987 pub fn name(mut self) -> String {
4988 self.path.push(Module::NAME_FIELD.name);
4989 self.finish()
4990 }
4991 pub fn contents(mut self) -> String {
4992 self.path.push(Module::CONTENTS_FIELD.name);
4993 self.finish()
4994 }
4995 pub fn datatypes(mut self) -> DatatypeDescriptorFieldPathBuilder {
4996 self.path.push(Module::DATATYPES_FIELD.name);
4997 DatatypeDescriptorFieldPathBuilder::new_with_base(self.path)
4998 }
4999 pub fn functions(mut self) -> FunctionDescriptorFieldPathBuilder {
5000 self.path.push(Module::FUNCTIONS_FIELD.name);
5001 FunctionDescriptorFieldPathBuilder::new_with_base(self.path)
5002 }
5003 }
5004 impl DatatypeDescriptor {
5005 pub const TYPE_NAME_FIELD: &'static MessageField = &MessageField {
5006 name: "type_name",
5007 json_name: "typeName",
5008 number: 1i32,
5009 message_fields: None,
5010 };
5011 pub const DEFINING_ID_FIELD: &'static MessageField = &MessageField {
5012 name: "defining_id",
5013 json_name: "definingId",
5014 number: 2i32,
5015 message_fields: None,
5016 };
5017 pub const MODULE_FIELD: &'static MessageField = &MessageField {
5018 name: "module",
5019 json_name: "module",
5020 number: 3i32,
5021 message_fields: None,
5022 };
5023 pub const NAME_FIELD: &'static MessageField = &MessageField {
5024 name: "name",
5025 json_name: "name",
5026 number: 4i32,
5027 message_fields: None,
5028 };
5029 pub const ABILITIES_FIELD: &'static MessageField = &MessageField {
5030 name: "abilities",
5031 json_name: "abilities",
5032 number: 5i32,
5033 message_fields: None,
5034 };
5035 pub const TYPE_PARAMETERS_FIELD: &'static MessageField = &MessageField {
5036 name: "type_parameters",
5037 json_name: "typeParameters",
5038 number: 6i32,
5039 message_fields: Some(TypeParameter::FIELDS),
5040 };
5041 pub const KIND_FIELD: &'static MessageField = &MessageField {
5042 name: "kind",
5043 json_name: "kind",
5044 number: 7i32,
5045 message_fields: None,
5046 };
5047 pub const FIELDS_FIELD: &'static MessageField = &MessageField {
5048 name: "fields",
5049 json_name: "fields",
5050 number: 8i32,
5051 message_fields: Some(FieldDescriptor::FIELDS),
5052 };
5053 pub const VARIANTS_FIELD: &'static MessageField = &MessageField {
5054 name: "variants",
5055 json_name: "variants",
5056 number: 9i32,
5057 message_fields: Some(VariantDescriptor::FIELDS),
5058 };
5059 }
5060 impl MessageFields for DatatypeDescriptor {
5061 const FIELDS: &'static [&'static MessageField] = &[
5062 Self::TYPE_NAME_FIELD,
5063 Self::DEFINING_ID_FIELD,
5064 Self::MODULE_FIELD,
5065 Self::NAME_FIELD,
5066 Self::ABILITIES_FIELD,
5067 Self::TYPE_PARAMETERS_FIELD,
5068 Self::KIND_FIELD,
5069 Self::FIELDS_FIELD,
5070 Self::VARIANTS_FIELD,
5071 ];
5072 }
5073 impl DatatypeDescriptor {
5074 pub fn path_builder() -> DatatypeDescriptorFieldPathBuilder {
5075 DatatypeDescriptorFieldPathBuilder::new()
5076 }
5077 }
5078 pub struct DatatypeDescriptorFieldPathBuilder {
5079 path: Vec<&'static str>,
5080 }
5081 impl DatatypeDescriptorFieldPathBuilder {
5082 #[allow(clippy::new_without_default)]
5083 pub fn new() -> Self {
5084 Self { path: Default::default() }
5085 }
5086 #[doc(hidden)]
5087 pub fn new_with_base(base: Vec<&'static str>) -> Self {
5088 Self { path: base }
5089 }
5090 pub fn finish(self) -> String {
5091 self.path.join(".")
5092 }
5093 pub fn type_name(mut self) -> String {
5094 self.path.push(DatatypeDescriptor::TYPE_NAME_FIELD.name);
5095 self.finish()
5096 }
5097 pub fn defining_id(mut self) -> String {
5098 self.path.push(DatatypeDescriptor::DEFINING_ID_FIELD.name);
5099 self.finish()
5100 }
5101 pub fn module(mut self) -> String {
5102 self.path.push(DatatypeDescriptor::MODULE_FIELD.name);
5103 self.finish()
5104 }
5105 pub fn name(mut self) -> String {
5106 self.path.push(DatatypeDescriptor::NAME_FIELD.name);
5107 self.finish()
5108 }
5109 pub fn abilities(mut self) -> String {
5110 self.path.push(DatatypeDescriptor::ABILITIES_FIELD.name);
5111 self.finish()
5112 }
5113 pub fn type_parameters(mut self) -> TypeParameterFieldPathBuilder {
5114 self.path.push(DatatypeDescriptor::TYPE_PARAMETERS_FIELD.name);
5115 TypeParameterFieldPathBuilder::new_with_base(self.path)
5116 }
5117 pub fn kind(mut self) -> String {
5118 self.path.push(DatatypeDescriptor::KIND_FIELD.name);
5119 self.finish()
5120 }
5121 pub fn fields(mut self) -> FieldDescriptorFieldPathBuilder {
5122 self.path.push(DatatypeDescriptor::FIELDS_FIELD.name);
5123 FieldDescriptorFieldPathBuilder::new_with_base(self.path)
5124 }
5125 pub fn variants(mut self) -> VariantDescriptorFieldPathBuilder {
5126 self.path.push(DatatypeDescriptor::VARIANTS_FIELD.name);
5127 VariantDescriptorFieldPathBuilder::new_with_base(self.path)
5128 }
5129 }
5130 impl TypeParameter {
5131 pub const CONSTRAINTS_FIELD: &'static MessageField = &MessageField {
5132 name: "constraints",
5133 json_name: "constraints",
5134 number: 1i32,
5135 message_fields: None,
5136 };
5137 pub const IS_PHANTOM_FIELD: &'static MessageField = &MessageField {
5138 name: "is_phantom",
5139 json_name: "isPhantom",
5140 number: 2i32,
5141 message_fields: None,
5142 };
5143 }
5144 impl MessageFields for TypeParameter {
5145 const FIELDS: &'static [&'static MessageField] = &[
5146 Self::CONSTRAINTS_FIELD,
5147 Self::IS_PHANTOM_FIELD,
5148 ];
5149 }
5150 impl TypeParameter {
5151 pub fn path_builder() -> TypeParameterFieldPathBuilder {
5152 TypeParameterFieldPathBuilder::new()
5153 }
5154 }
5155 pub struct TypeParameterFieldPathBuilder {
5156 path: Vec<&'static str>,
5157 }
5158 impl TypeParameterFieldPathBuilder {
5159 #[allow(clippy::new_without_default)]
5160 pub fn new() -> Self {
5161 Self { path: Default::default() }
5162 }
5163 #[doc(hidden)]
5164 pub fn new_with_base(base: Vec<&'static str>) -> Self {
5165 Self { path: base }
5166 }
5167 pub fn finish(self) -> String {
5168 self.path.join(".")
5169 }
5170 pub fn constraints(mut self) -> String {
5171 self.path.push(TypeParameter::CONSTRAINTS_FIELD.name);
5172 self.finish()
5173 }
5174 pub fn is_phantom(mut self) -> String {
5175 self.path.push(TypeParameter::IS_PHANTOM_FIELD.name);
5176 self.finish()
5177 }
5178 }
5179 impl FieldDescriptor {
5180 pub const NAME_FIELD: &'static MessageField = &MessageField {
5181 name: "name",
5182 json_name: "name",
5183 number: 1i32,
5184 message_fields: None,
5185 };
5186 pub const POSITION_FIELD: &'static MessageField = &MessageField {
5187 name: "position",
5188 json_name: "position",
5189 number: 2i32,
5190 message_fields: None,
5191 };
5192 pub const TYPE_FIELD: &'static MessageField = &MessageField {
5193 name: "type",
5194 json_name: "type",
5195 number: 3i32,
5196 message_fields: Some(OpenSignatureBody::FIELDS),
5197 };
5198 }
5199 impl MessageFields for FieldDescriptor {
5200 const FIELDS: &'static [&'static MessageField] = &[
5201 Self::NAME_FIELD,
5202 Self::POSITION_FIELD,
5203 Self::TYPE_FIELD,
5204 ];
5205 }
5206 impl FieldDescriptor {
5207 pub fn path_builder() -> FieldDescriptorFieldPathBuilder {
5208 FieldDescriptorFieldPathBuilder::new()
5209 }
5210 }
5211 pub struct FieldDescriptorFieldPathBuilder {
5212 path: Vec<&'static str>,
5213 }
5214 impl FieldDescriptorFieldPathBuilder {
5215 #[allow(clippy::new_without_default)]
5216 pub fn new() -> Self {
5217 Self { path: Default::default() }
5218 }
5219 #[doc(hidden)]
5220 pub fn new_with_base(base: Vec<&'static str>) -> Self {
5221 Self { path: base }
5222 }
5223 pub fn finish(self) -> String {
5224 self.path.join(".")
5225 }
5226 pub fn name(mut self) -> String {
5227 self.path.push(FieldDescriptor::NAME_FIELD.name);
5228 self.finish()
5229 }
5230 pub fn position(mut self) -> String {
5231 self.path.push(FieldDescriptor::POSITION_FIELD.name);
5232 self.finish()
5233 }
5234 pub fn r#type(mut self) -> OpenSignatureBodyFieldPathBuilder {
5235 self.path.push(FieldDescriptor::TYPE_FIELD.name);
5236 OpenSignatureBodyFieldPathBuilder::new_with_base(self.path)
5237 }
5238 }
5239 impl VariantDescriptor {
5240 pub const NAME_FIELD: &'static MessageField = &MessageField {
5241 name: "name",
5242 json_name: "name",
5243 number: 1i32,
5244 message_fields: None,
5245 };
5246 pub const POSITION_FIELD: &'static MessageField = &MessageField {
5247 name: "position",
5248 json_name: "position",
5249 number: 2i32,
5250 message_fields: None,
5251 };
5252 pub const FIELDS_FIELD: &'static MessageField = &MessageField {
5253 name: "fields",
5254 json_name: "fields",
5255 number: 3i32,
5256 message_fields: Some(FieldDescriptor::FIELDS),
5257 };
5258 }
5259 impl MessageFields for VariantDescriptor {
5260 const FIELDS: &'static [&'static MessageField] = &[
5261 Self::NAME_FIELD,
5262 Self::POSITION_FIELD,
5263 Self::FIELDS_FIELD,
5264 ];
5265 }
5266 impl VariantDescriptor {
5267 pub fn path_builder() -> VariantDescriptorFieldPathBuilder {
5268 VariantDescriptorFieldPathBuilder::new()
5269 }
5270 }
5271 pub struct VariantDescriptorFieldPathBuilder {
5272 path: Vec<&'static str>,
5273 }
5274 impl VariantDescriptorFieldPathBuilder {
5275 #[allow(clippy::new_without_default)]
5276 pub fn new() -> Self {
5277 Self { path: Default::default() }
5278 }
5279 #[doc(hidden)]
5280 pub fn new_with_base(base: Vec<&'static str>) -> Self {
5281 Self { path: base }
5282 }
5283 pub fn finish(self) -> String {
5284 self.path.join(".")
5285 }
5286 pub fn name(mut self) -> String {
5287 self.path.push(VariantDescriptor::NAME_FIELD.name);
5288 self.finish()
5289 }
5290 pub fn position(mut self) -> String {
5291 self.path.push(VariantDescriptor::POSITION_FIELD.name);
5292 self.finish()
5293 }
5294 pub fn fields(mut self) -> FieldDescriptorFieldPathBuilder {
5295 self.path.push(VariantDescriptor::FIELDS_FIELD.name);
5296 FieldDescriptorFieldPathBuilder::new_with_base(self.path)
5297 }
5298 }
5299 impl OpenSignatureBody {
5300 pub const TYPE_FIELD: &'static MessageField = &MessageField {
5301 name: "type",
5302 json_name: "type",
5303 number: 1i32,
5304 message_fields: None,
5305 };
5306 pub const TYPE_NAME_FIELD: &'static MessageField = &MessageField {
5307 name: "type_name",
5308 json_name: "typeName",
5309 number: 2i32,
5310 message_fields: None,
5311 };
5312 pub const TYPE_PARAMETER_INSTANTIATION_FIELD: &'static MessageField = &MessageField {
5313 name: "type_parameter_instantiation",
5314 json_name: "typeParameterInstantiation",
5315 number: 3i32,
5316 message_fields: None,
5317 };
5318 pub const TYPE_PARAMETER_FIELD: &'static MessageField = &MessageField {
5319 name: "type_parameter",
5320 json_name: "typeParameter",
5321 number: 4i32,
5322 message_fields: None,
5323 };
5324 }
5325 impl MessageFields for OpenSignatureBody {
5326 const FIELDS: &'static [&'static MessageField] = &[
5327 Self::TYPE_FIELD,
5328 Self::TYPE_NAME_FIELD,
5329 Self::TYPE_PARAMETER_INSTANTIATION_FIELD,
5330 Self::TYPE_PARAMETER_FIELD,
5331 ];
5332 }
5333 impl OpenSignatureBody {
5334 pub fn path_builder() -> OpenSignatureBodyFieldPathBuilder {
5335 OpenSignatureBodyFieldPathBuilder::new()
5336 }
5337 }
5338 pub struct OpenSignatureBodyFieldPathBuilder {
5339 path: Vec<&'static str>,
5340 }
5341 impl OpenSignatureBodyFieldPathBuilder {
5342 #[allow(clippy::new_without_default)]
5343 pub fn new() -> Self {
5344 Self { path: Default::default() }
5345 }
5346 #[doc(hidden)]
5347 pub fn new_with_base(base: Vec<&'static str>) -> Self {
5348 Self { path: base }
5349 }
5350 pub fn finish(self) -> String {
5351 self.path.join(".")
5352 }
5353 pub fn r#type(mut self) -> String {
5354 self.path.push(OpenSignatureBody::TYPE_FIELD.name);
5355 self.finish()
5356 }
5357 pub fn type_name(mut self) -> String {
5358 self.path.push(OpenSignatureBody::TYPE_NAME_FIELD.name);
5359 self.finish()
5360 }
5361 pub fn type_parameter_instantiation(mut self) -> String {
5362 self.path.push(OpenSignatureBody::TYPE_PARAMETER_INSTANTIATION_FIELD.name);
5363 self.finish()
5364 }
5365 pub fn type_parameter(mut self) -> String {
5366 self.path.push(OpenSignatureBody::TYPE_PARAMETER_FIELD.name);
5367 self.finish()
5368 }
5369 }
5370 impl FunctionDescriptor {
5371 pub const NAME_FIELD: &'static MessageField = &MessageField {
5372 name: "name",
5373 json_name: "name",
5374 number: 1i32,
5375 message_fields: None,
5376 };
5377 pub const VISIBILITY_FIELD: &'static MessageField = &MessageField {
5378 name: "visibility",
5379 json_name: "visibility",
5380 number: 5i32,
5381 message_fields: None,
5382 };
5383 pub const IS_ENTRY_FIELD: &'static MessageField = &MessageField {
5384 name: "is_entry",
5385 json_name: "isEntry",
5386 number: 6i32,
5387 message_fields: None,
5388 };
5389 pub const TYPE_PARAMETERS_FIELD: &'static MessageField = &MessageField {
5390 name: "type_parameters",
5391 json_name: "typeParameters",
5392 number: 7i32,
5393 message_fields: Some(TypeParameter::FIELDS),
5394 };
5395 pub const PARAMETERS_FIELD: &'static MessageField = &MessageField {
5396 name: "parameters",
5397 json_name: "parameters",
5398 number: 8i32,
5399 message_fields: Some(OpenSignature::FIELDS),
5400 };
5401 pub const RETURNS_FIELD: &'static MessageField = &MessageField {
5402 name: "returns",
5403 json_name: "returns",
5404 number: 9i32,
5405 message_fields: Some(OpenSignature::FIELDS),
5406 };
5407 }
5408 impl MessageFields for FunctionDescriptor {
5409 const FIELDS: &'static [&'static MessageField] = &[
5410 Self::NAME_FIELD,
5411 Self::VISIBILITY_FIELD,
5412 Self::IS_ENTRY_FIELD,
5413 Self::TYPE_PARAMETERS_FIELD,
5414 Self::PARAMETERS_FIELD,
5415 Self::RETURNS_FIELD,
5416 ];
5417 }
5418 impl FunctionDescriptor {
5419 pub fn path_builder() -> FunctionDescriptorFieldPathBuilder {
5420 FunctionDescriptorFieldPathBuilder::new()
5421 }
5422 }
5423 pub struct FunctionDescriptorFieldPathBuilder {
5424 path: Vec<&'static str>,
5425 }
5426 impl FunctionDescriptorFieldPathBuilder {
5427 #[allow(clippy::new_without_default)]
5428 pub fn new() -> Self {
5429 Self { path: Default::default() }
5430 }
5431 #[doc(hidden)]
5432 pub fn new_with_base(base: Vec<&'static str>) -> Self {
5433 Self { path: base }
5434 }
5435 pub fn finish(self) -> String {
5436 self.path.join(".")
5437 }
5438 pub fn name(mut self) -> String {
5439 self.path.push(FunctionDescriptor::NAME_FIELD.name);
5440 self.finish()
5441 }
5442 pub fn visibility(mut self) -> String {
5443 self.path.push(FunctionDescriptor::VISIBILITY_FIELD.name);
5444 self.finish()
5445 }
5446 pub fn is_entry(mut self) -> String {
5447 self.path.push(FunctionDescriptor::IS_ENTRY_FIELD.name);
5448 self.finish()
5449 }
5450 pub fn type_parameters(mut self) -> TypeParameterFieldPathBuilder {
5451 self.path.push(FunctionDescriptor::TYPE_PARAMETERS_FIELD.name);
5452 TypeParameterFieldPathBuilder::new_with_base(self.path)
5453 }
5454 pub fn parameters(mut self) -> OpenSignatureFieldPathBuilder {
5455 self.path.push(FunctionDescriptor::PARAMETERS_FIELD.name);
5456 OpenSignatureFieldPathBuilder::new_with_base(self.path)
5457 }
5458 pub fn returns(mut self) -> OpenSignatureFieldPathBuilder {
5459 self.path.push(FunctionDescriptor::RETURNS_FIELD.name);
5460 OpenSignatureFieldPathBuilder::new_with_base(self.path)
5461 }
5462 }
5463 impl OpenSignature {
5464 pub const REFERENCE_FIELD: &'static MessageField = &MessageField {
5465 name: "reference",
5466 json_name: "reference",
5467 number: 1i32,
5468 message_fields: None,
5469 };
5470 pub const BODY_FIELD: &'static MessageField = &MessageField {
5471 name: "body",
5472 json_name: "body",
5473 number: 2i32,
5474 message_fields: Some(OpenSignatureBody::FIELDS),
5475 };
5476 }
5477 impl MessageFields for OpenSignature {
5478 const FIELDS: &'static [&'static MessageField] = &[
5479 Self::REFERENCE_FIELD,
5480 Self::BODY_FIELD,
5481 ];
5482 }
5483 impl OpenSignature {
5484 pub fn path_builder() -> OpenSignatureFieldPathBuilder {
5485 OpenSignatureFieldPathBuilder::new()
5486 }
5487 }
5488 pub struct OpenSignatureFieldPathBuilder {
5489 path: Vec<&'static str>,
5490 }
5491 impl OpenSignatureFieldPathBuilder {
5492 #[allow(clippy::new_without_default)]
5493 pub fn new() -> Self {
5494 Self { path: Default::default() }
5495 }
5496 #[doc(hidden)]
5497 pub fn new_with_base(base: Vec<&'static str>) -> Self {
5498 Self { path: base }
5499 }
5500 pub fn finish(self) -> String {
5501 self.path.join(".")
5502 }
5503 pub fn reference(mut self) -> String {
5504 self.path.push(OpenSignature::REFERENCE_FIELD.name);
5505 self.finish()
5506 }
5507 pub fn body(mut self) -> OpenSignatureBodyFieldPathBuilder {
5508 self.path.push(OpenSignature::BODY_FIELD.name);
5509 OpenSignatureBodyFieldPathBuilder::new_with_base(self.path)
5510 }
5511 }
5512 impl TypeOrigin {
5513 pub const MODULE_NAME_FIELD: &'static MessageField = &MessageField {
5514 name: "module_name",
5515 json_name: "moduleName",
5516 number: 1i32,
5517 message_fields: None,
5518 };
5519 pub const DATATYPE_NAME_FIELD: &'static MessageField = &MessageField {
5520 name: "datatype_name",
5521 json_name: "datatypeName",
5522 number: 2i32,
5523 message_fields: None,
5524 };
5525 pub const PACKAGE_ID_FIELD: &'static MessageField = &MessageField {
5526 name: "package_id",
5527 json_name: "packageId",
5528 number: 3i32,
5529 message_fields: None,
5530 };
5531 }
5532 impl MessageFields for TypeOrigin {
5533 const FIELDS: &'static [&'static MessageField] = &[
5534 Self::MODULE_NAME_FIELD,
5535 Self::DATATYPE_NAME_FIELD,
5536 Self::PACKAGE_ID_FIELD,
5537 ];
5538 }
5539 impl TypeOrigin {
5540 pub fn path_builder() -> TypeOriginFieldPathBuilder {
5541 TypeOriginFieldPathBuilder::new()
5542 }
5543 }
5544 pub struct TypeOriginFieldPathBuilder {
5545 path: Vec<&'static str>,
5546 }
5547 impl TypeOriginFieldPathBuilder {
5548 #[allow(clippy::new_without_default)]
5549 pub fn new() -> Self {
5550 Self { path: Default::default() }
5551 }
5552 #[doc(hidden)]
5553 pub fn new_with_base(base: Vec<&'static str>) -> Self {
5554 Self { path: base }
5555 }
5556 pub fn finish(self) -> String {
5557 self.path.join(".")
5558 }
5559 pub fn module_name(mut self) -> String {
5560 self.path.push(TypeOrigin::MODULE_NAME_FIELD.name);
5561 self.finish()
5562 }
5563 pub fn datatype_name(mut self) -> String {
5564 self.path.push(TypeOrigin::DATATYPE_NAME_FIELD.name);
5565 self.finish()
5566 }
5567 pub fn package_id(mut self) -> String {
5568 self.path.push(TypeOrigin::PACKAGE_ID_FIELD.name);
5569 self.finish()
5570 }
5571 }
5572 impl Linkage {
5573 pub const ORIGINAL_ID_FIELD: &'static MessageField = &MessageField {
5574 name: "original_id",
5575 json_name: "originalId",
5576 number: 1i32,
5577 message_fields: None,
5578 };
5579 pub const UPGRADED_ID_FIELD: &'static MessageField = &MessageField {
5580 name: "upgraded_id",
5581 json_name: "upgradedId",
5582 number: 2i32,
5583 message_fields: None,
5584 };
5585 pub const UPGRADED_VERSION_FIELD: &'static MessageField = &MessageField {
5586 name: "upgraded_version",
5587 json_name: "upgradedVersion",
5588 number: 3i32,
5589 message_fields: None,
5590 };
5591 }
5592 impl MessageFields for Linkage {
5593 const FIELDS: &'static [&'static MessageField] = &[
5594 Self::ORIGINAL_ID_FIELD,
5595 Self::UPGRADED_ID_FIELD,
5596 Self::UPGRADED_VERSION_FIELD,
5597 ];
5598 }
5599 impl Linkage {
5600 pub fn path_builder() -> LinkageFieldPathBuilder {
5601 LinkageFieldPathBuilder::new()
5602 }
5603 }
5604 pub struct LinkageFieldPathBuilder {
5605 path: Vec<&'static str>,
5606 }
5607 impl LinkageFieldPathBuilder {
5608 #[allow(clippy::new_without_default)]
5609 pub fn new() -> Self {
5610 Self { path: Default::default() }
5611 }
5612 #[doc(hidden)]
5613 pub fn new_with_base(base: Vec<&'static str>) -> Self {
5614 Self { path: base }
5615 }
5616 pub fn finish(self) -> String {
5617 self.path.join(".")
5618 }
5619 pub fn original_id(mut self) -> String {
5620 self.path.push(Linkage::ORIGINAL_ID_FIELD.name);
5621 self.finish()
5622 }
5623 pub fn upgraded_id(mut self) -> String {
5624 self.path.push(Linkage::UPGRADED_ID_FIELD.name);
5625 self.finish()
5626 }
5627 pub fn upgraded_version(mut self) -> String {
5628 self.path.push(Linkage::UPGRADED_VERSION_FIELD.name);
5629 self.finish()
5630 }
5631 }
5632 impl GetPackageRequest {
5633 pub const PACKAGE_ID_FIELD: &'static MessageField = &MessageField {
5634 name: "package_id",
5635 json_name: "packageId",
5636 number: 1i32,
5637 message_fields: None,
5638 };
5639 }
5640 impl MessageFields for GetPackageRequest {
5641 const FIELDS: &'static [&'static MessageField] = &[Self::PACKAGE_ID_FIELD];
5642 }
5643 impl GetPackageRequest {
5644 pub fn path_builder() -> GetPackageRequestFieldPathBuilder {
5645 GetPackageRequestFieldPathBuilder::new()
5646 }
5647 }
5648 pub struct GetPackageRequestFieldPathBuilder {
5649 path: Vec<&'static str>,
5650 }
5651 impl GetPackageRequestFieldPathBuilder {
5652 #[allow(clippy::new_without_default)]
5653 pub fn new() -> Self {
5654 Self { path: Default::default() }
5655 }
5656 #[doc(hidden)]
5657 pub fn new_with_base(base: Vec<&'static str>) -> Self {
5658 Self { path: base }
5659 }
5660 pub fn finish(self) -> String {
5661 self.path.join(".")
5662 }
5663 pub fn package_id(mut self) -> String {
5664 self.path.push(GetPackageRequest::PACKAGE_ID_FIELD.name);
5665 self.finish()
5666 }
5667 }
5668 impl GetPackageResponse {
5669 pub const PACKAGE_FIELD: &'static MessageField = &MessageField {
5670 name: "package",
5671 json_name: "package",
5672 number: 1i32,
5673 message_fields: Some(Package::FIELDS),
5674 };
5675 }
5676 impl MessageFields for GetPackageResponse {
5677 const FIELDS: &'static [&'static MessageField] = &[Self::PACKAGE_FIELD];
5678 }
5679 impl GetPackageResponse {
5680 pub fn path_builder() -> GetPackageResponseFieldPathBuilder {
5681 GetPackageResponseFieldPathBuilder::new()
5682 }
5683 }
5684 pub struct GetPackageResponseFieldPathBuilder {
5685 path: Vec<&'static str>,
5686 }
5687 impl GetPackageResponseFieldPathBuilder {
5688 #[allow(clippy::new_without_default)]
5689 pub fn new() -> Self {
5690 Self { path: Default::default() }
5691 }
5692 #[doc(hidden)]
5693 pub fn new_with_base(base: Vec<&'static str>) -> Self {
5694 Self { path: base }
5695 }
5696 pub fn finish(self) -> String {
5697 self.path.join(".")
5698 }
5699 pub fn package(mut self) -> PackageFieldPathBuilder {
5700 self.path.push(GetPackageResponse::PACKAGE_FIELD.name);
5701 PackageFieldPathBuilder::new_with_base(self.path)
5702 }
5703 }
5704 impl GetDatatypeRequest {
5705 pub const PACKAGE_ID_FIELD: &'static MessageField = &MessageField {
5706 name: "package_id",
5707 json_name: "packageId",
5708 number: 1i32,
5709 message_fields: None,
5710 };
5711 pub const MODULE_NAME_FIELD: &'static MessageField = &MessageField {
5712 name: "module_name",
5713 json_name: "moduleName",
5714 number: 2i32,
5715 message_fields: None,
5716 };
5717 pub const NAME_FIELD: &'static MessageField = &MessageField {
5718 name: "name",
5719 json_name: "name",
5720 number: 3i32,
5721 message_fields: None,
5722 };
5723 }
5724 impl MessageFields for GetDatatypeRequest {
5725 const FIELDS: &'static [&'static MessageField] = &[
5726 Self::PACKAGE_ID_FIELD,
5727 Self::MODULE_NAME_FIELD,
5728 Self::NAME_FIELD,
5729 ];
5730 }
5731 impl GetDatatypeRequest {
5732 pub fn path_builder() -> GetDatatypeRequestFieldPathBuilder {
5733 GetDatatypeRequestFieldPathBuilder::new()
5734 }
5735 }
5736 pub struct GetDatatypeRequestFieldPathBuilder {
5737 path: Vec<&'static str>,
5738 }
5739 impl GetDatatypeRequestFieldPathBuilder {
5740 #[allow(clippy::new_without_default)]
5741 pub fn new() -> Self {
5742 Self { path: Default::default() }
5743 }
5744 #[doc(hidden)]
5745 pub fn new_with_base(base: Vec<&'static str>) -> Self {
5746 Self { path: base }
5747 }
5748 pub fn finish(self) -> String {
5749 self.path.join(".")
5750 }
5751 pub fn package_id(mut self) -> String {
5752 self.path.push(GetDatatypeRequest::PACKAGE_ID_FIELD.name);
5753 self.finish()
5754 }
5755 pub fn module_name(mut self) -> String {
5756 self.path.push(GetDatatypeRequest::MODULE_NAME_FIELD.name);
5757 self.finish()
5758 }
5759 pub fn name(mut self) -> String {
5760 self.path.push(GetDatatypeRequest::NAME_FIELD.name);
5761 self.finish()
5762 }
5763 }
5764 impl GetDatatypeResponse {
5765 pub const DATATYPE_FIELD: &'static MessageField = &MessageField {
5766 name: "datatype",
5767 json_name: "datatype",
5768 number: 1i32,
5769 message_fields: Some(DatatypeDescriptor::FIELDS),
5770 };
5771 }
5772 impl MessageFields for GetDatatypeResponse {
5773 const FIELDS: &'static [&'static MessageField] = &[Self::DATATYPE_FIELD];
5774 }
5775 impl GetDatatypeResponse {
5776 pub fn path_builder() -> GetDatatypeResponseFieldPathBuilder {
5777 GetDatatypeResponseFieldPathBuilder::new()
5778 }
5779 }
5780 pub struct GetDatatypeResponseFieldPathBuilder {
5781 path: Vec<&'static str>,
5782 }
5783 impl GetDatatypeResponseFieldPathBuilder {
5784 #[allow(clippy::new_without_default)]
5785 pub fn new() -> Self {
5786 Self { path: Default::default() }
5787 }
5788 #[doc(hidden)]
5789 pub fn new_with_base(base: Vec<&'static str>) -> Self {
5790 Self { path: base }
5791 }
5792 pub fn finish(self) -> String {
5793 self.path.join(".")
5794 }
5795 pub fn datatype(mut self) -> DatatypeDescriptorFieldPathBuilder {
5796 self.path.push(GetDatatypeResponse::DATATYPE_FIELD.name);
5797 DatatypeDescriptorFieldPathBuilder::new_with_base(self.path)
5798 }
5799 }
5800 impl GetFunctionRequest {
5801 pub const PACKAGE_ID_FIELD: &'static MessageField = &MessageField {
5802 name: "package_id",
5803 json_name: "packageId",
5804 number: 1i32,
5805 message_fields: None,
5806 };
5807 pub const MODULE_NAME_FIELD: &'static MessageField = &MessageField {
5808 name: "module_name",
5809 json_name: "moduleName",
5810 number: 2i32,
5811 message_fields: None,
5812 };
5813 pub const NAME_FIELD: &'static MessageField = &MessageField {
5814 name: "name",
5815 json_name: "name",
5816 number: 3i32,
5817 message_fields: None,
5818 };
5819 }
5820 impl MessageFields for GetFunctionRequest {
5821 const FIELDS: &'static [&'static MessageField] = &[
5822 Self::PACKAGE_ID_FIELD,
5823 Self::MODULE_NAME_FIELD,
5824 Self::NAME_FIELD,
5825 ];
5826 }
5827 impl GetFunctionRequest {
5828 pub fn path_builder() -> GetFunctionRequestFieldPathBuilder {
5829 GetFunctionRequestFieldPathBuilder::new()
5830 }
5831 }
5832 pub struct GetFunctionRequestFieldPathBuilder {
5833 path: Vec<&'static str>,
5834 }
5835 impl GetFunctionRequestFieldPathBuilder {
5836 #[allow(clippy::new_without_default)]
5837 pub fn new() -> Self {
5838 Self { path: Default::default() }
5839 }
5840 #[doc(hidden)]
5841 pub fn new_with_base(base: Vec<&'static str>) -> Self {
5842 Self { path: base }
5843 }
5844 pub fn finish(self) -> String {
5845 self.path.join(".")
5846 }
5847 pub fn package_id(mut self) -> String {
5848 self.path.push(GetFunctionRequest::PACKAGE_ID_FIELD.name);
5849 self.finish()
5850 }
5851 pub fn module_name(mut self) -> String {
5852 self.path.push(GetFunctionRequest::MODULE_NAME_FIELD.name);
5853 self.finish()
5854 }
5855 pub fn name(mut self) -> String {
5856 self.path.push(GetFunctionRequest::NAME_FIELD.name);
5857 self.finish()
5858 }
5859 }
5860 impl GetFunctionResponse {
5861 pub const FUNCTION_FIELD: &'static MessageField = &MessageField {
5862 name: "function",
5863 json_name: "function",
5864 number: 1i32,
5865 message_fields: Some(FunctionDescriptor::FIELDS),
5866 };
5867 }
5868 impl MessageFields for GetFunctionResponse {
5869 const FIELDS: &'static [&'static MessageField] = &[Self::FUNCTION_FIELD];
5870 }
5871 impl GetFunctionResponse {
5872 pub fn path_builder() -> GetFunctionResponseFieldPathBuilder {
5873 GetFunctionResponseFieldPathBuilder::new()
5874 }
5875 }
5876 pub struct GetFunctionResponseFieldPathBuilder {
5877 path: Vec<&'static str>,
5878 }
5879 impl GetFunctionResponseFieldPathBuilder {
5880 #[allow(clippy::new_without_default)]
5881 pub fn new() -> Self {
5882 Self { path: Default::default() }
5883 }
5884 #[doc(hidden)]
5885 pub fn new_with_base(base: Vec<&'static str>) -> Self {
5886 Self { path: base }
5887 }
5888 pub fn finish(self) -> String {
5889 self.path.join(".")
5890 }
5891 pub fn function(mut self) -> FunctionDescriptorFieldPathBuilder {
5892 self.path.push(GetFunctionResponse::FUNCTION_FIELD.name);
5893 FunctionDescriptorFieldPathBuilder::new_with_base(self.path)
5894 }
5895 }
5896 impl ListPackageVersionsRequest {
5897 pub const PACKAGE_ID_FIELD: &'static MessageField = &MessageField {
5898 name: "package_id",
5899 json_name: "packageId",
5900 number: 1i32,
5901 message_fields: None,
5902 };
5903 pub const PAGE_SIZE_FIELD: &'static MessageField = &MessageField {
5904 name: "page_size",
5905 json_name: "pageSize",
5906 number: 2i32,
5907 message_fields: None,
5908 };
5909 pub const PAGE_TOKEN_FIELD: &'static MessageField = &MessageField {
5910 name: "page_token",
5911 json_name: "pageToken",
5912 number: 3i32,
5913 message_fields: None,
5914 };
5915 }
5916 impl MessageFields for ListPackageVersionsRequest {
5917 const FIELDS: &'static [&'static MessageField] = &[
5918 Self::PACKAGE_ID_FIELD,
5919 Self::PAGE_SIZE_FIELD,
5920 Self::PAGE_TOKEN_FIELD,
5921 ];
5922 }
5923 impl ListPackageVersionsRequest {
5924 pub fn path_builder() -> ListPackageVersionsRequestFieldPathBuilder {
5925 ListPackageVersionsRequestFieldPathBuilder::new()
5926 }
5927 }
5928 pub struct ListPackageVersionsRequestFieldPathBuilder {
5929 path: Vec<&'static str>,
5930 }
5931 impl ListPackageVersionsRequestFieldPathBuilder {
5932 #[allow(clippy::new_without_default)]
5933 pub fn new() -> Self {
5934 Self { path: Default::default() }
5935 }
5936 #[doc(hidden)]
5937 pub fn new_with_base(base: Vec<&'static str>) -> Self {
5938 Self { path: base }
5939 }
5940 pub fn finish(self) -> String {
5941 self.path.join(".")
5942 }
5943 pub fn package_id(mut self) -> String {
5944 self.path.push(ListPackageVersionsRequest::PACKAGE_ID_FIELD.name);
5945 self.finish()
5946 }
5947 pub fn page_size(mut self) -> String {
5948 self.path.push(ListPackageVersionsRequest::PAGE_SIZE_FIELD.name);
5949 self.finish()
5950 }
5951 pub fn page_token(mut self) -> String {
5952 self.path.push(ListPackageVersionsRequest::PAGE_TOKEN_FIELD.name);
5953 self.finish()
5954 }
5955 }
5956 impl ListPackageVersionsResponse {
5957 pub const VERSIONS_FIELD: &'static MessageField = &MessageField {
5958 name: "versions",
5959 json_name: "versions",
5960 number: 1i32,
5961 message_fields: Some(PackageVersion::FIELDS),
5962 };
5963 pub const NEXT_PAGE_TOKEN_FIELD: &'static MessageField = &MessageField {
5964 name: "next_page_token",
5965 json_name: "nextPageToken",
5966 number: 2i32,
5967 message_fields: None,
5968 };
5969 }
5970 impl MessageFields for ListPackageVersionsResponse {
5971 const FIELDS: &'static [&'static MessageField] = &[
5972 Self::VERSIONS_FIELD,
5973 Self::NEXT_PAGE_TOKEN_FIELD,
5974 ];
5975 }
5976 impl ListPackageVersionsResponse {
5977 pub fn path_builder() -> ListPackageVersionsResponseFieldPathBuilder {
5978 ListPackageVersionsResponseFieldPathBuilder::new()
5979 }
5980 }
5981 pub struct ListPackageVersionsResponseFieldPathBuilder {
5982 path: Vec<&'static str>,
5983 }
5984 impl ListPackageVersionsResponseFieldPathBuilder {
5985 #[allow(clippy::new_without_default)]
5986 pub fn new() -> Self {
5987 Self { path: Default::default() }
5988 }
5989 #[doc(hidden)]
5990 pub fn new_with_base(base: Vec<&'static str>) -> Self {
5991 Self { path: base }
5992 }
5993 pub fn finish(self) -> String {
5994 self.path.join(".")
5995 }
5996 pub fn versions(mut self) -> PackageVersionFieldPathBuilder {
5997 self.path.push(ListPackageVersionsResponse::VERSIONS_FIELD.name);
5998 PackageVersionFieldPathBuilder::new_with_base(self.path)
5999 }
6000 pub fn next_page_token(mut self) -> String {
6001 self.path.push(ListPackageVersionsResponse::NEXT_PAGE_TOKEN_FIELD.name);
6002 self.finish()
6003 }
6004 }
6005 impl PackageVersion {
6006 pub const PACKAGE_ID_FIELD: &'static MessageField = &MessageField {
6007 name: "package_id",
6008 json_name: "packageId",
6009 number: 1i32,
6010 message_fields: None,
6011 };
6012 pub const VERSION_FIELD: &'static MessageField = &MessageField {
6013 name: "version",
6014 json_name: "version",
6015 number: 2i32,
6016 message_fields: None,
6017 };
6018 }
6019 impl MessageFields for PackageVersion {
6020 const FIELDS: &'static [&'static MessageField] = &[
6021 Self::PACKAGE_ID_FIELD,
6022 Self::VERSION_FIELD,
6023 ];
6024 }
6025 impl PackageVersion {
6026 pub fn path_builder() -> PackageVersionFieldPathBuilder {
6027 PackageVersionFieldPathBuilder::new()
6028 }
6029 }
6030 pub struct PackageVersionFieldPathBuilder {
6031 path: Vec<&'static str>,
6032 }
6033 impl PackageVersionFieldPathBuilder {
6034 #[allow(clippy::new_without_default)]
6035 pub fn new() -> Self {
6036 Self { path: Default::default() }
6037 }
6038 #[doc(hidden)]
6039 pub fn new_with_base(base: Vec<&'static str>) -> Self {
6040 Self { path: base }
6041 }
6042 pub fn finish(self) -> String {
6043 self.path.join(".")
6044 }
6045 pub fn package_id(mut self) -> String {
6046 self.path.push(PackageVersion::PACKAGE_ID_FIELD.name);
6047 self.finish()
6048 }
6049 pub fn version(mut self) -> String {
6050 self.path.push(PackageVersion::VERSION_FIELD.name);
6051 self.finish()
6052 }
6053 }
6054 impl LookupNameRequest {
6055 pub const NAME_FIELD: &'static MessageField = &MessageField {
6056 name: "name",
6057 json_name: "name",
6058 number: 1i32,
6059 message_fields: None,
6060 };
6061 }
6062 impl MessageFields for LookupNameRequest {
6063 const FIELDS: &'static [&'static MessageField] = &[Self::NAME_FIELD];
6064 }
6065 impl LookupNameRequest {
6066 pub fn path_builder() -> LookupNameRequestFieldPathBuilder {
6067 LookupNameRequestFieldPathBuilder::new()
6068 }
6069 }
6070 pub struct LookupNameRequestFieldPathBuilder {
6071 path: Vec<&'static str>,
6072 }
6073 impl LookupNameRequestFieldPathBuilder {
6074 #[allow(clippy::new_without_default)]
6075 pub fn new() -> Self {
6076 Self { path: Default::default() }
6077 }
6078 #[doc(hidden)]
6079 pub fn new_with_base(base: Vec<&'static str>) -> Self {
6080 Self { path: base }
6081 }
6082 pub fn finish(self) -> String {
6083 self.path.join(".")
6084 }
6085 pub fn name(mut self) -> String {
6086 self.path.push(LookupNameRequest::NAME_FIELD.name);
6087 self.finish()
6088 }
6089 }
6090 impl LookupNameResponse {
6091 pub const RECORD_FIELD: &'static MessageField = &MessageField {
6092 name: "record",
6093 json_name: "record",
6094 number: 1i32,
6095 message_fields: Some(NameRecord::FIELDS),
6096 };
6097 }
6098 impl MessageFields for LookupNameResponse {
6099 const FIELDS: &'static [&'static MessageField] = &[Self::RECORD_FIELD];
6100 }
6101 impl LookupNameResponse {
6102 pub fn path_builder() -> LookupNameResponseFieldPathBuilder {
6103 LookupNameResponseFieldPathBuilder::new()
6104 }
6105 }
6106 pub struct LookupNameResponseFieldPathBuilder {
6107 path: Vec<&'static str>,
6108 }
6109 impl LookupNameResponseFieldPathBuilder {
6110 #[allow(clippy::new_without_default)]
6111 pub fn new() -> Self {
6112 Self { path: Default::default() }
6113 }
6114 #[doc(hidden)]
6115 pub fn new_with_base(base: Vec<&'static str>) -> Self {
6116 Self { path: base }
6117 }
6118 pub fn finish(self) -> String {
6119 self.path.join(".")
6120 }
6121 pub fn record(mut self) -> NameRecordFieldPathBuilder {
6122 self.path.push(LookupNameResponse::RECORD_FIELD.name);
6123 NameRecordFieldPathBuilder::new_with_base(self.path)
6124 }
6125 }
6126 impl ReverseLookupNameRequest {
6127 pub const ADDRESS_FIELD: &'static MessageField = &MessageField {
6128 name: "address",
6129 json_name: "address",
6130 number: 1i32,
6131 message_fields: None,
6132 };
6133 }
6134 impl MessageFields for ReverseLookupNameRequest {
6135 const FIELDS: &'static [&'static MessageField] = &[Self::ADDRESS_FIELD];
6136 }
6137 impl ReverseLookupNameRequest {
6138 pub fn path_builder() -> ReverseLookupNameRequestFieldPathBuilder {
6139 ReverseLookupNameRequestFieldPathBuilder::new()
6140 }
6141 }
6142 pub struct ReverseLookupNameRequestFieldPathBuilder {
6143 path: Vec<&'static str>,
6144 }
6145 impl ReverseLookupNameRequestFieldPathBuilder {
6146 #[allow(clippy::new_without_default)]
6147 pub fn new() -> Self {
6148 Self { path: Default::default() }
6149 }
6150 #[doc(hidden)]
6151 pub fn new_with_base(base: Vec<&'static str>) -> Self {
6152 Self { path: base }
6153 }
6154 pub fn finish(self) -> String {
6155 self.path.join(".")
6156 }
6157 pub fn address(mut self) -> String {
6158 self.path.push(ReverseLookupNameRequest::ADDRESS_FIELD.name);
6159 self.finish()
6160 }
6161 }
6162 impl ReverseLookupNameResponse {
6163 pub const RECORD_FIELD: &'static MessageField = &MessageField {
6164 name: "record",
6165 json_name: "record",
6166 number: 1i32,
6167 message_fields: Some(NameRecord::FIELDS),
6168 };
6169 }
6170 impl MessageFields for ReverseLookupNameResponse {
6171 const FIELDS: &'static [&'static MessageField] = &[Self::RECORD_FIELD];
6172 }
6173 impl ReverseLookupNameResponse {
6174 pub fn path_builder() -> ReverseLookupNameResponseFieldPathBuilder {
6175 ReverseLookupNameResponseFieldPathBuilder::new()
6176 }
6177 }
6178 pub struct ReverseLookupNameResponseFieldPathBuilder {
6179 path: Vec<&'static str>,
6180 }
6181 impl ReverseLookupNameResponseFieldPathBuilder {
6182 #[allow(clippy::new_without_default)]
6183 pub fn new() -> Self {
6184 Self { path: Default::default() }
6185 }
6186 #[doc(hidden)]
6187 pub fn new_with_base(base: Vec<&'static str>) -> Self {
6188 Self { path: base }
6189 }
6190 pub fn finish(self) -> String {
6191 self.path.join(".")
6192 }
6193 pub fn record(mut self) -> NameRecordFieldPathBuilder {
6194 self.path.push(ReverseLookupNameResponse::RECORD_FIELD.name);
6195 NameRecordFieldPathBuilder::new_with_base(self.path)
6196 }
6197 }
6198 impl NameRecord {
6199 pub const ID_FIELD: &'static MessageField = &MessageField {
6200 name: "id",
6201 json_name: "id",
6202 number: 1i32,
6203 message_fields: None,
6204 };
6205 pub const NAME_FIELD: &'static MessageField = &MessageField {
6206 name: "name",
6207 json_name: "name",
6208 number: 2i32,
6209 message_fields: None,
6210 };
6211 pub const REGISTRATION_NFT_ID_FIELD: &'static MessageField = &MessageField {
6212 name: "registration_nft_id",
6213 json_name: "registrationNftId",
6214 number: 3i32,
6215 message_fields: None,
6216 };
6217 pub const EXPIRATION_TIMESTAMP_FIELD: &'static MessageField = &MessageField {
6218 name: "expiration_timestamp",
6219 json_name: "expirationTimestamp",
6220 number: 4i32,
6221 message_fields: None,
6222 };
6223 pub const TARGET_ADDRESS_FIELD: &'static MessageField = &MessageField {
6224 name: "target_address",
6225 json_name: "targetAddress",
6226 number: 5i32,
6227 message_fields: None,
6228 };
6229 pub const DATA_FIELD: &'static MessageField = &MessageField {
6230 name: "data",
6231 json_name: "data",
6232 number: 6i32,
6233 message_fields: None,
6234 };
6235 }
6236 impl MessageFields for NameRecord {
6237 const FIELDS: &'static [&'static MessageField] = &[
6238 Self::ID_FIELD,
6239 Self::NAME_FIELD,
6240 Self::REGISTRATION_NFT_ID_FIELD,
6241 Self::EXPIRATION_TIMESTAMP_FIELD,
6242 Self::TARGET_ADDRESS_FIELD,
6243 Self::DATA_FIELD,
6244 ];
6245 }
6246 impl NameRecord {
6247 pub fn path_builder() -> NameRecordFieldPathBuilder {
6248 NameRecordFieldPathBuilder::new()
6249 }
6250 }
6251 pub struct NameRecordFieldPathBuilder {
6252 path: Vec<&'static str>,
6253 }
6254 impl NameRecordFieldPathBuilder {
6255 #[allow(clippy::new_without_default)]
6256 pub fn new() -> Self {
6257 Self { path: Default::default() }
6258 }
6259 #[doc(hidden)]
6260 pub fn new_with_base(base: Vec<&'static str>) -> Self {
6261 Self { path: base }
6262 }
6263 pub fn finish(self) -> String {
6264 self.path.join(".")
6265 }
6266 pub fn id(mut self) -> String {
6267 self.path.push(NameRecord::ID_FIELD.name);
6268 self.finish()
6269 }
6270 pub fn name(mut self) -> String {
6271 self.path.push(NameRecord::NAME_FIELD.name);
6272 self.finish()
6273 }
6274 pub fn registration_nft_id(mut self) -> String {
6275 self.path.push(NameRecord::REGISTRATION_NFT_ID_FIELD.name);
6276 self.finish()
6277 }
6278 pub fn expiration_timestamp(mut self) -> String {
6279 self.path.push(NameRecord::EXPIRATION_TIMESTAMP_FIELD.name);
6280 self.finish()
6281 }
6282 pub fn target_address(mut self) -> String {
6283 self.path.push(NameRecord::TARGET_ADDRESS_FIELD.name);
6284 self.finish()
6285 }
6286 pub fn data(mut self) -> String {
6287 self.path.push(NameRecord::DATA_FIELD.name);
6288 self.finish()
6289 }
6290 }
6291 impl Object {
6292 pub const BCS_FIELD: &'static MessageField = &MessageField {
6293 name: "bcs",
6294 json_name: "bcs",
6295 number: 1i32,
6296 message_fields: Some(Bcs::FIELDS),
6297 };
6298 pub const OBJECT_ID_FIELD: &'static MessageField = &MessageField {
6299 name: "object_id",
6300 json_name: "objectId",
6301 number: 2i32,
6302 message_fields: None,
6303 };
6304 pub const VERSION_FIELD: &'static MessageField = &MessageField {
6305 name: "version",
6306 json_name: "version",
6307 number: 3i32,
6308 message_fields: None,
6309 };
6310 pub const DIGEST_FIELD: &'static MessageField = &MessageField {
6311 name: "digest",
6312 json_name: "digest",
6313 number: 4i32,
6314 message_fields: None,
6315 };
6316 pub const OWNER_FIELD: &'static MessageField = &MessageField {
6317 name: "owner",
6318 json_name: "owner",
6319 number: 5i32,
6320 message_fields: Some(Owner::FIELDS),
6321 };
6322 pub const OBJECT_TYPE_FIELD: &'static MessageField = &MessageField {
6323 name: "object_type",
6324 json_name: "objectType",
6325 number: 6i32,
6326 message_fields: None,
6327 };
6328 pub const HAS_PUBLIC_TRANSFER_FIELD: &'static MessageField = &MessageField {
6329 name: "has_public_transfer",
6330 json_name: "hasPublicTransfer",
6331 number: 7i32,
6332 message_fields: None,
6333 };
6334 pub const CONTENTS_FIELD: &'static MessageField = &MessageField {
6335 name: "contents",
6336 json_name: "contents",
6337 number: 8i32,
6338 message_fields: Some(Bcs::FIELDS),
6339 };
6340 pub const PACKAGE_FIELD: &'static MessageField = &MessageField {
6341 name: "package",
6342 json_name: "package",
6343 number: 9i32,
6344 message_fields: Some(Package::FIELDS),
6345 };
6346 pub const PREVIOUS_TRANSACTION_FIELD: &'static MessageField = &MessageField {
6347 name: "previous_transaction",
6348 json_name: "previousTransaction",
6349 number: 10i32,
6350 message_fields: None,
6351 };
6352 pub const STORAGE_REBATE_FIELD: &'static MessageField = &MessageField {
6353 name: "storage_rebate",
6354 json_name: "storageRebate",
6355 number: 11i32,
6356 message_fields: None,
6357 };
6358 pub const JSON_FIELD: &'static MessageField = &MessageField {
6359 name: "json",
6360 json_name: "json",
6361 number: 100i32,
6362 message_fields: None,
6363 };
6364 pub const BALANCE_FIELD: &'static MessageField = &MessageField {
6365 name: "balance",
6366 json_name: "balance",
6367 number: 101i32,
6368 message_fields: None,
6369 };
6370 pub const DISPLAY_FIELD: &'static MessageField = &MessageField {
6371 name: "display",
6372 json_name: "display",
6373 number: 102i32,
6374 message_fields: Some(Display::FIELDS),
6375 };
6376 }
6377 impl MessageFields for Object {
6378 const FIELDS: &'static [&'static MessageField] = &[
6379 Self::BCS_FIELD,
6380 Self::OBJECT_ID_FIELD,
6381 Self::VERSION_FIELD,
6382 Self::DIGEST_FIELD,
6383 Self::OWNER_FIELD,
6384 Self::OBJECT_TYPE_FIELD,
6385 Self::HAS_PUBLIC_TRANSFER_FIELD,
6386 Self::CONTENTS_FIELD,
6387 Self::PACKAGE_FIELD,
6388 Self::PREVIOUS_TRANSACTION_FIELD,
6389 Self::STORAGE_REBATE_FIELD,
6390 Self::JSON_FIELD,
6391 Self::BALANCE_FIELD,
6392 Self::DISPLAY_FIELD,
6393 ];
6394 }
6395 impl Object {
6396 pub fn path_builder() -> ObjectFieldPathBuilder {
6397 ObjectFieldPathBuilder::new()
6398 }
6399 }
6400 pub struct ObjectFieldPathBuilder {
6401 path: Vec<&'static str>,
6402 }
6403 impl ObjectFieldPathBuilder {
6404 #[allow(clippy::new_without_default)]
6405 pub fn new() -> Self {
6406 Self { path: Default::default() }
6407 }
6408 #[doc(hidden)]
6409 pub fn new_with_base(base: Vec<&'static str>) -> Self {
6410 Self { path: base }
6411 }
6412 pub fn finish(self) -> String {
6413 self.path.join(".")
6414 }
6415 pub fn bcs(mut self) -> BcsFieldPathBuilder {
6416 self.path.push(Object::BCS_FIELD.name);
6417 BcsFieldPathBuilder::new_with_base(self.path)
6418 }
6419 pub fn object_id(mut self) -> String {
6420 self.path.push(Object::OBJECT_ID_FIELD.name);
6421 self.finish()
6422 }
6423 pub fn version(mut self) -> String {
6424 self.path.push(Object::VERSION_FIELD.name);
6425 self.finish()
6426 }
6427 pub fn digest(mut self) -> String {
6428 self.path.push(Object::DIGEST_FIELD.name);
6429 self.finish()
6430 }
6431 pub fn owner(mut self) -> OwnerFieldPathBuilder {
6432 self.path.push(Object::OWNER_FIELD.name);
6433 OwnerFieldPathBuilder::new_with_base(self.path)
6434 }
6435 pub fn object_type(mut self) -> String {
6436 self.path.push(Object::OBJECT_TYPE_FIELD.name);
6437 self.finish()
6438 }
6439 pub fn has_public_transfer(mut self) -> String {
6440 self.path.push(Object::HAS_PUBLIC_TRANSFER_FIELD.name);
6441 self.finish()
6442 }
6443 pub fn contents(mut self) -> BcsFieldPathBuilder {
6444 self.path.push(Object::CONTENTS_FIELD.name);
6445 BcsFieldPathBuilder::new_with_base(self.path)
6446 }
6447 pub fn package(mut self) -> PackageFieldPathBuilder {
6448 self.path.push(Object::PACKAGE_FIELD.name);
6449 PackageFieldPathBuilder::new_with_base(self.path)
6450 }
6451 pub fn previous_transaction(mut self) -> String {
6452 self.path.push(Object::PREVIOUS_TRANSACTION_FIELD.name);
6453 self.finish()
6454 }
6455 pub fn storage_rebate(mut self) -> String {
6456 self.path.push(Object::STORAGE_REBATE_FIELD.name);
6457 self.finish()
6458 }
6459 pub fn json(mut self) -> String {
6460 self.path.push(Object::JSON_FIELD.name);
6461 self.finish()
6462 }
6463 pub fn balance(mut self) -> String {
6464 self.path.push(Object::BALANCE_FIELD.name);
6465 self.finish()
6466 }
6467 pub fn display(mut self) -> DisplayFieldPathBuilder {
6468 self.path.push(Object::DISPLAY_FIELD.name);
6469 DisplayFieldPathBuilder::new_with_base(self.path)
6470 }
6471 }
6472 impl ObjectSet {
6473 pub const OBJECTS_FIELD: &'static MessageField = &MessageField {
6474 name: "objects",
6475 json_name: "objects",
6476 number: 1i32,
6477 message_fields: Some(Object::FIELDS),
6478 };
6479 }
6480 impl MessageFields for ObjectSet {
6481 const FIELDS: &'static [&'static MessageField] = &[Self::OBJECTS_FIELD];
6482 }
6483 impl ObjectSet {
6484 pub fn path_builder() -> ObjectSetFieldPathBuilder {
6485 ObjectSetFieldPathBuilder::new()
6486 }
6487 }
6488 pub struct ObjectSetFieldPathBuilder {
6489 path: Vec<&'static str>,
6490 }
6491 impl ObjectSetFieldPathBuilder {
6492 #[allow(clippy::new_without_default)]
6493 pub fn new() -> Self {
6494 Self { path: Default::default() }
6495 }
6496 #[doc(hidden)]
6497 pub fn new_with_base(base: Vec<&'static str>) -> Self {
6498 Self { path: base }
6499 }
6500 pub fn finish(self) -> String {
6501 self.path.join(".")
6502 }
6503 pub fn objects(mut self) -> ObjectFieldPathBuilder {
6504 self.path.push(ObjectSet::OBJECTS_FIELD.name);
6505 ObjectFieldPathBuilder::new_with_base(self.path)
6506 }
6507 }
6508 impl Display {
6509 pub const OUTPUT_FIELD: &'static MessageField = &MessageField {
6510 name: "output",
6511 json_name: "output",
6512 number: 1i32,
6513 message_fields: None,
6514 };
6515 pub const ERRORS_FIELD: &'static MessageField = &MessageField {
6516 name: "errors",
6517 json_name: "errors",
6518 number: 2i32,
6519 message_fields: None,
6520 };
6521 }
6522 impl MessageFields for Display {
6523 const FIELDS: &'static [&'static MessageField] = &[
6524 Self::OUTPUT_FIELD,
6525 Self::ERRORS_FIELD,
6526 ];
6527 }
6528 impl Display {
6529 pub fn path_builder() -> DisplayFieldPathBuilder {
6530 DisplayFieldPathBuilder::new()
6531 }
6532 }
6533 pub struct DisplayFieldPathBuilder {
6534 path: Vec<&'static str>,
6535 }
6536 impl DisplayFieldPathBuilder {
6537 #[allow(clippy::new_without_default)]
6538 pub fn new() -> Self {
6539 Self { path: Default::default() }
6540 }
6541 #[doc(hidden)]
6542 pub fn new_with_base(base: Vec<&'static str>) -> Self {
6543 Self { path: base }
6544 }
6545 pub fn finish(self) -> String {
6546 self.path.join(".")
6547 }
6548 pub fn output(mut self) -> String {
6549 self.path.push(Display::OUTPUT_FIELD.name);
6550 self.finish()
6551 }
6552 pub fn errors(mut self) -> String {
6553 self.path.push(Display::ERRORS_FIELD.name);
6554 self.finish()
6555 }
6556 }
6557 impl ObjectReference {
6558 pub const OBJECT_ID_FIELD: &'static MessageField = &MessageField {
6559 name: "object_id",
6560 json_name: "objectId",
6561 number: 1i32,
6562 message_fields: None,
6563 };
6564 pub const VERSION_FIELD: &'static MessageField = &MessageField {
6565 name: "version",
6566 json_name: "version",
6567 number: 2i32,
6568 message_fields: None,
6569 };
6570 pub const DIGEST_FIELD: &'static MessageField = &MessageField {
6571 name: "digest",
6572 json_name: "digest",
6573 number: 3i32,
6574 message_fields: None,
6575 };
6576 }
6577 impl MessageFields for ObjectReference {
6578 const FIELDS: &'static [&'static MessageField] = &[
6579 Self::OBJECT_ID_FIELD,
6580 Self::VERSION_FIELD,
6581 Self::DIGEST_FIELD,
6582 ];
6583 }
6584 impl ObjectReference {
6585 pub fn path_builder() -> ObjectReferenceFieldPathBuilder {
6586 ObjectReferenceFieldPathBuilder::new()
6587 }
6588 }
6589 pub struct ObjectReferenceFieldPathBuilder {
6590 path: Vec<&'static str>,
6591 }
6592 impl ObjectReferenceFieldPathBuilder {
6593 #[allow(clippy::new_without_default)]
6594 pub fn new() -> Self {
6595 Self { path: Default::default() }
6596 }
6597 #[doc(hidden)]
6598 pub fn new_with_base(base: Vec<&'static str>) -> Self {
6599 Self { path: base }
6600 }
6601 pub fn finish(self) -> String {
6602 self.path.join(".")
6603 }
6604 pub fn object_id(mut self) -> String {
6605 self.path.push(ObjectReference::OBJECT_ID_FIELD.name);
6606 self.finish()
6607 }
6608 pub fn version(mut self) -> String {
6609 self.path.push(ObjectReference::VERSION_FIELD.name);
6610 self.finish()
6611 }
6612 pub fn digest(mut self) -> String {
6613 self.path.push(ObjectReference::DIGEST_FIELD.name);
6614 self.finish()
6615 }
6616 }
6617 impl Owner {
6618 pub const KIND_FIELD: &'static MessageField = &MessageField {
6619 name: "kind",
6620 json_name: "kind",
6621 number: 1i32,
6622 message_fields: None,
6623 };
6624 pub const ADDRESS_FIELD: &'static MessageField = &MessageField {
6625 name: "address",
6626 json_name: "address",
6627 number: 2i32,
6628 message_fields: None,
6629 };
6630 pub const VERSION_FIELD: &'static MessageField = &MessageField {
6631 name: "version",
6632 json_name: "version",
6633 number: 3i32,
6634 message_fields: None,
6635 };
6636 }
6637 impl MessageFields for Owner {
6638 const FIELDS: &'static [&'static MessageField] = &[
6639 Self::KIND_FIELD,
6640 Self::ADDRESS_FIELD,
6641 Self::VERSION_FIELD,
6642 ];
6643 }
6644 impl Owner {
6645 pub fn path_builder() -> OwnerFieldPathBuilder {
6646 OwnerFieldPathBuilder::new()
6647 }
6648 }
6649 pub struct OwnerFieldPathBuilder {
6650 path: Vec<&'static str>,
6651 }
6652 impl OwnerFieldPathBuilder {
6653 #[allow(clippy::new_without_default)]
6654 pub fn new() -> Self {
6655 Self { path: Default::default() }
6656 }
6657 #[doc(hidden)]
6658 pub fn new_with_base(base: Vec<&'static str>) -> Self {
6659 Self { path: base }
6660 }
6661 pub fn finish(self) -> String {
6662 self.path.join(".")
6663 }
6664 pub fn kind(mut self) -> String {
6665 self.path.push(Owner::KIND_FIELD.name);
6666 self.finish()
6667 }
6668 pub fn address(mut self) -> String {
6669 self.path.push(Owner::ADDRESS_FIELD.name);
6670 self.finish()
6671 }
6672 pub fn version(mut self) -> String {
6673 self.path.push(Owner::VERSION_FIELD.name);
6674 self.finish()
6675 }
6676 }
6677 impl ProtocolConfig {
6678 pub const PROTOCOL_VERSION_FIELD: &'static MessageField = &MessageField {
6679 name: "protocol_version",
6680 json_name: "protocolVersion",
6681 number: 1i32,
6682 message_fields: None,
6683 };
6684 pub const FEATURE_FLAGS_FIELD: &'static MessageField = &MessageField {
6685 name: "feature_flags",
6686 json_name: "featureFlags",
6687 number: 2i32,
6688 message_fields: None,
6689 };
6690 pub const ATTRIBUTES_FIELD: &'static MessageField = &MessageField {
6691 name: "attributes",
6692 json_name: "attributes",
6693 number: 3i32,
6694 message_fields: None,
6695 };
6696 pub const CONFIGS_FIELD: &'static MessageField = &MessageField {
6697 name: "configs",
6698 json_name: "configs",
6699 number: 4i32,
6700 message_fields: None,
6701 };
6702 }
6703 impl MessageFields for ProtocolConfig {
6704 const FIELDS: &'static [&'static MessageField] = &[
6705 Self::PROTOCOL_VERSION_FIELD,
6706 Self::FEATURE_FLAGS_FIELD,
6707 Self::ATTRIBUTES_FIELD,
6708 Self::CONFIGS_FIELD,
6709 ];
6710 }
6711 impl ProtocolConfig {
6712 pub fn path_builder() -> ProtocolConfigFieldPathBuilder {
6713 ProtocolConfigFieldPathBuilder::new()
6714 }
6715 }
6716 pub struct ProtocolConfigFieldPathBuilder {
6717 path: Vec<&'static str>,
6718 }
6719 impl ProtocolConfigFieldPathBuilder {
6720 #[allow(clippy::new_without_default)]
6721 pub fn new() -> Self {
6722 Self { path: Default::default() }
6723 }
6724 #[doc(hidden)]
6725 pub fn new_with_base(base: Vec<&'static str>) -> Self {
6726 Self { path: base }
6727 }
6728 pub fn finish(self) -> String {
6729 self.path.join(".")
6730 }
6731 pub fn protocol_version(mut self) -> String {
6732 self.path.push(ProtocolConfig::PROTOCOL_VERSION_FIELD.name);
6733 self.finish()
6734 }
6735 pub fn feature_flags(mut self) -> String {
6736 self.path.push(ProtocolConfig::FEATURE_FLAGS_FIELD.name);
6737 self.finish()
6738 }
6739 pub fn attributes(mut self) -> String {
6740 self.path.push(ProtocolConfig::ATTRIBUTES_FIELD.name);
6741 self.finish()
6742 }
6743 pub fn configs(mut self) -> String {
6744 self.path.push(ProtocolConfig::CONFIGS_FIELD.name);
6745 self.finish()
6746 }
6747 }
6748 impl QueryOptions {
6749 pub const LIMIT_FIELD: &'static MessageField = &MessageField {
6750 name: "limit",
6751 json_name: "limit",
6752 number: 1i32,
6753 message_fields: None,
6754 };
6755 pub const AFTER_FIELD: &'static MessageField = &MessageField {
6756 name: "after",
6757 json_name: "after",
6758 number: 2i32,
6759 message_fields: None,
6760 };
6761 pub const BEFORE_FIELD: &'static MessageField = &MessageField {
6762 name: "before",
6763 json_name: "before",
6764 number: 3i32,
6765 message_fields: None,
6766 };
6767 pub const ORDERING_FIELD: &'static MessageField = &MessageField {
6768 name: "ordering",
6769 json_name: "ordering",
6770 number: 4i32,
6771 message_fields: None,
6772 };
6773 }
6774 impl MessageFields for QueryOptions {
6775 const FIELDS: &'static [&'static MessageField] = &[
6776 Self::LIMIT_FIELD,
6777 Self::AFTER_FIELD,
6778 Self::BEFORE_FIELD,
6779 Self::ORDERING_FIELD,
6780 ];
6781 }
6782 impl QueryOptions {
6783 pub fn path_builder() -> QueryOptionsFieldPathBuilder {
6784 QueryOptionsFieldPathBuilder::new()
6785 }
6786 }
6787 pub struct QueryOptionsFieldPathBuilder {
6788 path: Vec<&'static str>,
6789 }
6790 impl QueryOptionsFieldPathBuilder {
6791 #[allow(clippy::new_without_default)]
6792 pub fn new() -> Self {
6793 Self { path: Default::default() }
6794 }
6795 #[doc(hidden)]
6796 pub fn new_with_base(base: Vec<&'static str>) -> Self {
6797 Self { path: base }
6798 }
6799 pub fn finish(self) -> String {
6800 self.path.join(".")
6801 }
6802 pub fn limit(mut self) -> String {
6803 self.path.push(QueryOptions::LIMIT_FIELD.name);
6804 self.finish()
6805 }
6806 pub fn after(mut self) -> String {
6807 self.path.push(QueryOptions::AFTER_FIELD.name);
6808 self.finish()
6809 }
6810 pub fn before(mut self) -> String {
6811 self.path.push(QueryOptions::BEFORE_FIELD.name);
6812 self.finish()
6813 }
6814 pub fn ordering(mut self) -> String {
6815 self.path.push(QueryOptions::ORDERING_FIELD.name);
6816 self.finish()
6817 }
6818 }
6819 impl Watermark {
6820 pub const CURSOR_FIELD: &'static MessageField = &MessageField {
6821 name: "cursor",
6822 json_name: "cursor",
6823 number: 1i32,
6824 message_fields: None,
6825 };
6826 pub const CHECKPOINT_FIELD: &'static MessageField = &MessageField {
6827 name: "checkpoint",
6828 json_name: "checkpoint",
6829 number: 2i32,
6830 message_fields: None,
6831 };
6832 }
6833 impl MessageFields for Watermark {
6834 const FIELDS: &'static [&'static MessageField] = &[
6835 Self::CURSOR_FIELD,
6836 Self::CHECKPOINT_FIELD,
6837 ];
6838 }
6839 impl Watermark {
6840 pub fn path_builder() -> WatermarkFieldPathBuilder {
6841 WatermarkFieldPathBuilder::new()
6842 }
6843 }
6844 pub struct WatermarkFieldPathBuilder {
6845 path: Vec<&'static str>,
6846 }
6847 impl WatermarkFieldPathBuilder {
6848 #[allow(clippy::new_without_default)]
6849 pub fn new() -> Self {
6850 Self { path: Default::default() }
6851 }
6852 #[doc(hidden)]
6853 pub fn new_with_base(base: Vec<&'static str>) -> Self {
6854 Self { path: base }
6855 }
6856 pub fn finish(self) -> String {
6857 self.path.join(".")
6858 }
6859 pub fn cursor(mut self) -> String {
6860 self.path.push(Watermark::CURSOR_FIELD.name);
6861 self.finish()
6862 }
6863 pub fn checkpoint(mut self) -> String {
6864 self.path.push(Watermark::CHECKPOINT_FIELD.name);
6865 self.finish()
6866 }
6867 }
6868 impl QueryEnd {
6869 pub const REASON_FIELD: &'static MessageField = &MessageField {
6870 name: "reason",
6871 json_name: "reason",
6872 number: 1i32,
6873 message_fields: None,
6874 };
6875 }
6876 impl MessageFields for QueryEnd {
6877 const FIELDS: &'static [&'static MessageField] = &[Self::REASON_FIELD];
6878 }
6879 impl QueryEnd {
6880 pub fn path_builder() -> QueryEndFieldPathBuilder {
6881 QueryEndFieldPathBuilder::new()
6882 }
6883 }
6884 pub struct QueryEndFieldPathBuilder {
6885 path: Vec<&'static str>,
6886 }
6887 impl QueryEndFieldPathBuilder {
6888 #[allow(clippy::new_without_default)]
6889 pub fn new() -> Self {
6890 Self { path: Default::default() }
6891 }
6892 #[doc(hidden)]
6893 pub fn new_with_base(base: Vec<&'static str>) -> Self {
6894 Self { path: base }
6895 }
6896 pub fn finish(self) -> String {
6897 self.path.join(".")
6898 }
6899 pub fn reason(mut self) -> String {
6900 self.path.push(QueryEnd::REASON_FIELD.name);
6901 self.finish()
6902 }
6903 }
6904 impl UserSignature {
6905 pub const BCS_FIELD: &'static MessageField = &MessageField {
6906 name: "bcs",
6907 json_name: "bcs",
6908 number: 1i32,
6909 message_fields: Some(Bcs::FIELDS),
6910 };
6911 pub const SCHEME_FIELD: &'static MessageField = &MessageField {
6912 name: "scheme",
6913 json_name: "scheme",
6914 number: 2i32,
6915 message_fields: None,
6916 };
6917 pub const SIMPLE_FIELD: &'static MessageField = &MessageField {
6918 name: "simple",
6919 json_name: "simple",
6920 number: 3i32,
6921 message_fields: Some(SimpleSignature::FIELDS),
6922 };
6923 pub const MULTISIG_FIELD: &'static MessageField = &MessageField {
6924 name: "multisig",
6925 json_name: "multisig",
6926 number: 4i32,
6927 message_fields: Some(MultisigAggregatedSignature::FIELDS),
6928 };
6929 pub const ZKLOGIN_FIELD: &'static MessageField = &MessageField {
6930 name: "zklogin",
6931 json_name: "zklogin",
6932 number: 5i32,
6933 message_fields: Some(ZkLoginAuthenticator::FIELDS),
6934 };
6935 pub const PASSKEY_FIELD: &'static MessageField = &MessageField {
6936 name: "passkey",
6937 json_name: "passkey",
6938 number: 6i32,
6939 message_fields: Some(PasskeyAuthenticator::FIELDS),
6940 };
6941 }
6942 impl MessageFields for UserSignature {
6943 const FIELDS: &'static [&'static MessageField] = &[
6944 Self::BCS_FIELD,
6945 Self::SCHEME_FIELD,
6946 Self::SIMPLE_FIELD,
6947 Self::MULTISIG_FIELD,
6948 Self::ZKLOGIN_FIELD,
6949 Self::PASSKEY_FIELD,
6950 ];
6951 }
6952 impl UserSignature {
6953 pub fn path_builder() -> UserSignatureFieldPathBuilder {
6954 UserSignatureFieldPathBuilder::new()
6955 }
6956 }
6957 pub struct UserSignatureFieldPathBuilder {
6958 path: Vec<&'static str>,
6959 }
6960 impl UserSignatureFieldPathBuilder {
6961 #[allow(clippy::new_without_default)]
6962 pub fn new() -> Self {
6963 Self { path: Default::default() }
6964 }
6965 #[doc(hidden)]
6966 pub fn new_with_base(base: Vec<&'static str>) -> Self {
6967 Self { path: base }
6968 }
6969 pub fn finish(self) -> String {
6970 self.path.join(".")
6971 }
6972 pub fn bcs(mut self) -> BcsFieldPathBuilder {
6973 self.path.push(UserSignature::BCS_FIELD.name);
6974 BcsFieldPathBuilder::new_with_base(self.path)
6975 }
6976 pub fn scheme(mut self) -> String {
6977 self.path.push(UserSignature::SCHEME_FIELD.name);
6978 self.finish()
6979 }
6980 pub fn simple(mut self) -> SimpleSignatureFieldPathBuilder {
6981 self.path.push(UserSignature::SIMPLE_FIELD.name);
6982 SimpleSignatureFieldPathBuilder::new_with_base(self.path)
6983 }
6984 pub fn multisig(mut self) -> MultisigAggregatedSignatureFieldPathBuilder {
6985 self.path.push(UserSignature::MULTISIG_FIELD.name);
6986 MultisigAggregatedSignatureFieldPathBuilder::new_with_base(self.path)
6987 }
6988 pub fn zklogin(mut self) -> ZkLoginAuthenticatorFieldPathBuilder {
6989 self.path.push(UserSignature::ZKLOGIN_FIELD.name);
6990 ZkLoginAuthenticatorFieldPathBuilder::new_with_base(self.path)
6991 }
6992 pub fn passkey(mut self) -> PasskeyAuthenticatorFieldPathBuilder {
6993 self.path.push(UserSignature::PASSKEY_FIELD.name);
6994 PasskeyAuthenticatorFieldPathBuilder::new_with_base(self.path)
6995 }
6996 }
6997 impl SimpleSignature {
6998 pub const SCHEME_FIELD: &'static MessageField = &MessageField {
6999 name: "scheme",
7000 json_name: "scheme",
7001 number: 1i32,
7002 message_fields: None,
7003 };
7004 pub const SIGNATURE_FIELD: &'static MessageField = &MessageField {
7005 name: "signature",
7006 json_name: "signature",
7007 number: 2i32,
7008 message_fields: None,
7009 };
7010 pub const PUBLIC_KEY_FIELD: &'static MessageField = &MessageField {
7011 name: "public_key",
7012 json_name: "publicKey",
7013 number: 3i32,
7014 message_fields: None,
7015 };
7016 }
7017 impl MessageFields for SimpleSignature {
7018 const FIELDS: &'static [&'static MessageField] = &[
7019 Self::SCHEME_FIELD,
7020 Self::SIGNATURE_FIELD,
7021 Self::PUBLIC_KEY_FIELD,
7022 ];
7023 }
7024 impl SimpleSignature {
7025 pub fn path_builder() -> SimpleSignatureFieldPathBuilder {
7026 SimpleSignatureFieldPathBuilder::new()
7027 }
7028 }
7029 pub struct SimpleSignatureFieldPathBuilder {
7030 path: Vec<&'static str>,
7031 }
7032 impl SimpleSignatureFieldPathBuilder {
7033 #[allow(clippy::new_without_default)]
7034 pub fn new() -> Self {
7035 Self { path: Default::default() }
7036 }
7037 #[doc(hidden)]
7038 pub fn new_with_base(base: Vec<&'static str>) -> Self {
7039 Self { path: base }
7040 }
7041 pub fn finish(self) -> String {
7042 self.path.join(".")
7043 }
7044 pub fn scheme(mut self) -> String {
7045 self.path.push(SimpleSignature::SCHEME_FIELD.name);
7046 self.finish()
7047 }
7048 pub fn signature(mut self) -> String {
7049 self.path.push(SimpleSignature::SIGNATURE_FIELD.name);
7050 self.finish()
7051 }
7052 pub fn public_key(mut self) -> String {
7053 self.path.push(SimpleSignature::PUBLIC_KEY_FIELD.name);
7054 self.finish()
7055 }
7056 }
7057 impl ZkLoginPublicIdentifier {
7058 pub const ISS_FIELD: &'static MessageField = &MessageField {
7059 name: "iss",
7060 json_name: "iss",
7061 number: 1i32,
7062 message_fields: None,
7063 };
7064 pub const ADDRESS_SEED_FIELD: &'static MessageField = &MessageField {
7065 name: "address_seed",
7066 json_name: "addressSeed",
7067 number: 2i32,
7068 message_fields: None,
7069 };
7070 }
7071 impl MessageFields for ZkLoginPublicIdentifier {
7072 const FIELDS: &'static [&'static MessageField] = &[
7073 Self::ISS_FIELD,
7074 Self::ADDRESS_SEED_FIELD,
7075 ];
7076 }
7077 impl ZkLoginPublicIdentifier {
7078 pub fn path_builder() -> ZkLoginPublicIdentifierFieldPathBuilder {
7079 ZkLoginPublicIdentifierFieldPathBuilder::new()
7080 }
7081 }
7082 pub struct ZkLoginPublicIdentifierFieldPathBuilder {
7083 path: Vec<&'static str>,
7084 }
7085 impl ZkLoginPublicIdentifierFieldPathBuilder {
7086 #[allow(clippy::new_without_default)]
7087 pub fn new() -> Self {
7088 Self { path: Default::default() }
7089 }
7090 #[doc(hidden)]
7091 pub fn new_with_base(base: Vec<&'static str>) -> Self {
7092 Self { path: base }
7093 }
7094 pub fn finish(self) -> String {
7095 self.path.join(".")
7096 }
7097 pub fn iss(mut self) -> String {
7098 self.path.push(ZkLoginPublicIdentifier::ISS_FIELD.name);
7099 self.finish()
7100 }
7101 pub fn address_seed(mut self) -> String {
7102 self.path.push(ZkLoginPublicIdentifier::ADDRESS_SEED_FIELD.name);
7103 self.finish()
7104 }
7105 }
7106 impl MultisigMemberPublicKey {
7107 pub const SCHEME_FIELD: &'static MessageField = &MessageField {
7108 name: "scheme",
7109 json_name: "scheme",
7110 number: 1i32,
7111 message_fields: None,
7112 };
7113 pub const PUBLIC_KEY_FIELD: &'static MessageField = &MessageField {
7114 name: "public_key",
7115 json_name: "publicKey",
7116 number: 2i32,
7117 message_fields: None,
7118 };
7119 pub const ZKLOGIN_FIELD: &'static MessageField = &MessageField {
7120 name: "zklogin",
7121 json_name: "zklogin",
7122 number: 3i32,
7123 message_fields: Some(ZkLoginPublicIdentifier::FIELDS),
7124 };
7125 }
7126 impl MessageFields for MultisigMemberPublicKey {
7127 const FIELDS: &'static [&'static MessageField] = &[
7128 Self::SCHEME_FIELD,
7129 Self::PUBLIC_KEY_FIELD,
7130 Self::ZKLOGIN_FIELD,
7131 ];
7132 }
7133 impl MultisigMemberPublicKey {
7134 pub fn path_builder() -> MultisigMemberPublicKeyFieldPathBuilder {
7135 MultisigMemberPublicKeyFieldPathBuilder::new()
7136 }
7137 }
7138 pub struct MultisigMemberPublicKeyFieldPathBuilder {
7139 path: Vec<&'static str>,
7140 }
7141 impl MultisigMemberPublicKeyFieldPathBuilder {
7142 #[allow(clippy::new_without_default)]
7143 pub fn new() -> Self {
7144 Self { path: Default::default() }
7145 }
7146 #[doc(hidden)]
7147 pub fn new_with_base(base: Vec<&'static str>) -> Self {
7148 Self { path: base }
7149 }
7150 pub fn finish(self) -> String {
7151 self.path.join(".")
7152 }
7153 pub fn scheme(mut self) -> String {
7154 self.path.push(MultisigMemberPublicKey::SCHEME_FIELD.name);
7155 self.finish()
7156 }
7157 pub fn public_key(mut self) -> String {
7158 self.path.push(MultisigMemberPublicKey::PUBLIC_KEY_FIELD.name);
7159 self.finish()
7160 }
7161 pub fn zklogin(mut self) -> ZkLoginPublicIdentifierFieldPathBuilder {
7162 self.path.push(MultisigMemberPublicKey::ZKLOGIN_FIELD.name);
7163 ZkLoginPublicIdentifierFieldPathBuilder::new_with_base(self.path)
7164 }
7165 }
7166 impl MultisigMember {
7167 pub const PUBLIC_KEY_FIELD: &'static MessageField = &MessageField {
7168 name: "public_key",
7169 json_name: "publicKey",
7170 number: 1i32,
7171 message_fields: Some(MultisigMemberPublicKey::FIELDS),
7172 };
7173 pub const WEIGHT_FIELD: &'static MessageField = &MessageField {
7174 name: "weight",
7175 json_name: "weight",
7176 number: 2i32,
7177 message_fields: None,
7178 };
7179 }
7180 impl MessageFields for MultisigMember {
7181 const FIELDS: &'static [&'static MessageField] = &[
7182 Self::PUBLIC_KEY_FIELD,
7183 Self::WEIGHT_FIELD,
7184 ];
7185 }
7186 impl MultisigMember {
7187 pub fn path_builder() -> MultisigMemberFieldPathBuilder {
7188 MultisigMemberFieldPathBuilder::new()
7189 }
7190 }
7191 pub struct MultisigMemberFieldPathBuilder {
7192 path: Vec<&'static str>,
7193 }
7194 impl MultisigMemberFieldPathBuilder {
7195 #[allow(clippy::new_without_default)]
7196 pub fn new() -> Self {
7197 Self { path: Default::default() }
7198 }
7199 #[doc(hidden)]
7200 pub fn new_with_base(base: Vec<&'static str>) -> Self {
7201 Self { path: base }
7202 }
7203 pub fn finish(self) -> String {
7204 self.path.join(".")
7205 }
7206 pub fn public_key(mut self) -> MultisigMemberPublicKeyFieldPathBuilder {
7207 self.path.push(MultisigMember::PUBLIC_KEY_FIELD.name);
7208 MultisigMemberPublicKeyFieldPathBuilder::new_with_base(self.path)
7209 }
7210 pub fn weight(mut self) -> String {
7211 self.path.push(MultisigMember::WEIGHT_FIELD.name);
7212 self.finish()
7213 }
7214 }
7215 impl MultisigCommittee {
7216 pub const MEMBERS_FIELD: &'static MessageField = &MessageField {
7217 name: "members",
7218 json_name: "members",
7219 number: 1i32,
7220 message_fields: Some(MultisigMember::FIELDS),
7221 };
7222 pub const THRESHOLD_FIELD: &'static MessageField = &MessageField {
7223 name: "threshold",
7224 json_name: "threshold",
7225 number: 2i32,
7226 message_fields: None,
7227 };
7228 }
7229 impl MessageFields for MultisigCommittee {
7230 const FIELDS: &'static [&'static MessageField] = &[
7231 Self::MEMBERS_FIELD,
7232 Self::THRESHOLD_FIELD,
7233 ];
7234 }
7235 impl MultisigCommittee {
7236 pub fn path_builder() -> MultisigCommitteeFieldPathBuilder {
7237 MultisigCommitteeFieldPathBuilder::new()
7238 }
7239 }
7240 pub struct MultisigCommitteeFieldPathBuilder {
7241 path: Vec<&'static str>,
7242 }
7243 impl MultisigCommitteeFieldPathBuilder {
7244 #[allow(clippy::new_without_default)]
7245 pub fn new() -> Self {
7246 Self { path: Default::default() }
7247 }
7248 #[doc(hidden)]
7249 pub fn new_with_base(base: Vec<&'static str>) -> Self {
7250 Self { path: base }
7251 }
7252 pub fn finish(self) -> String {
7253 self.path.join(".")
7254 }
7255 pub fn members(mut self) -> MultisigMemberFieldPathBuilder {
7256 self.path.push(MultisigCommittee::MEMBERS_FIELD.name);
7257 MultisigMemberFieldPathBuilder::new_with_base(self.path)
7258 }
7259 pub fn threshold(mut self) -> String {
7260 self.path.push(MultisigCommittee::THRESHOLD_FIELD.name);
7261 self.finish()
7262 }
7263 }
7264 impl MultisigAggregatedSignature {
7265 pub const SIGNATURES_FIELD: &'static MessageField = &MessageField {
7266 name: "signatures",
7267 json_name: "signatures",
7268 number: 1i32,
7269 message_fields: Some(MultisigMemberSignature::FIELDS),
7270 };
7271 pub const BITMAP_FIELD: &'static MessageField = &MessageField {
7272 name: "bitmap",
7273 json_name: "bitmap",
7274 number: 2i32,
7275 message_fields: None,
7276 };
7277 pub const LEGACY_BITMAP_FIELD: &'static MessageField = &MessageField {
7278 name: "legacy_bitmap",
7279 json_name: "legacyBitmap",
7280 number: 3i32,
7281 message_fields: None,
7282 };
7283 pub const COMMITTEE_FIELD: &'static MessageField = &MessageField {
7284 name: "committee",
7285 json_name: "committee",
7286 number: 4i32,
7287 message_fields: Some(MultisigCommittee::FIELDS),
7288 };
7289 }
7290 impl MessageFields for MultisigAggregatedSignature {
7291 const FIELDS: &'static [&'static MessageField] = &[
7292 Self::SIGNATURES_FIELD,
7293 Self::BITMAP_FIELD,
7294 Self::LEGACY_BITMAP_FIELD,
7295 Self::COMMITTEE_FIELD,
7296 ];
7297 }
7298 impl MultisigAggregatedSignature {
7299 pub fn path_builder() -> MultisigAggregatedSignatureFieldPathBuilder {
7300 MultisigAggregatedSignatureFieldPathBuilder::new()
7301 }
7302 }
7303 pub struct MultisigAggregatedSignatureFieldPathBuilder {
7304 path: Vec<&'static str>,
7305 }
7306 impl MultisigAggregatedSignatureFieldPathBuilder {
7307 #[allow(clippy::new_without_default)]
7308 pub fn new() -> Self {
7309 Self { path: Default::default() }
7310 }
7311 #[doc(hidden)]
7312 pub fn new_with_base(base: Vec<&'static str>) -> Self {
7313 Self { path: base }
7314 }
7315 pub fn finish(self) -> String {
7316 self.path.join(".")
7317 }
7318 pub fn signatures(mut self) -> MultisigMemberSignatureFieldPathBuilder {
7319 self.path.push(MultisigAggregatedSignature::SIGNATURES_FIELD.name);
7320 MultisigMemberSignatureFieldPathBuilder::new_with_base(self.path)
7321 }
7322 pub fn bitmap(mut self) -> String {
7323 self.path.push(MultisigAggregatedSignature::BITMAP_FIELD.name);
7324 self.finish()
7325 }
7326 pub fn legacy_bitmap(mut self) -> String {
7327 self.path.push(MultisigAggregatedSignature::LEGACY_BITMAP_FIELD.name);
7328 self.finish()
7329 }
7330 pub fn committee(mut self) -> MultisigCommitteeFieldPathBuilder {
7331 self.path.push(MultisigAggregatedSignature::COMMITTEE_FIELD.name);
7332 MultisigCommitteeFieldPathBuilder::new_with_base(self.path)
7333 }
7334 }
7335 impl MultisigMemberSignature {
7336 pub const SCHEME_FIELD: &'static MessageField = &MessageField {
7337 name: "scheme",
7338 json_name: "scheme",
7339 number: 1i32,
7340 message_fields: None,
7341 };
7342 pub const SIGNATURE_FIELD: &'static MessageField = &MessageField {
7343 name: "signature",
7344 json_name: "signature",
7345 number: 2i32,
7346 message_fields: None,
7347 };
7348 pub const ZKLOGIN_FIELD: &'static MessageField = &MessageField {
7349 name: "zklogin",
7350 json_name: "zklogin",
7351 number: 3i32,
7352 message_fields: Some(ZkLoginAuthenticator::FIELDS),
7353 };
7354 pub const PASSKEY_FIELD: &'static MessageField = &MessageField {
7355 name: "passkey",
7356 json_name: "passkey",
7357 number: 4i32,
7358 message_fields: Some(PasskeyAuthenticator::FIELDS),
7359 };
7360 }
7361 impl MessageFields for MultisigMemberSignature {
7362 const FIELDS: &'static [&'static MessageField] = &[
7363 Self::SCHEME_FIELD,
7364 Self::SIGNATURE_FIELD,
7365 Self::ZKLOGIN_FIELD,
7366 Self::PASSKEY_FIELD,
7367 ];
7368 }
7369 impl MultisigMemberSignature {
7370 pub fn path_builder() -> MultisigMemberSignatureFieldPathBuilder {
7371 MultisigMemberSignatureFieldPathBuilder::new()
7372 }
7373 }
7374 pub struct MultisigMemberSignatureFieldPathBuilder {
7375 path: Vec<&'static str>,
7376 }
7377 impl MultisigMemberSignatureFieldPathBuilder {
7378 #[allow(clippy::new_without_default)]
7379 pub fn new() -> Self {
7380 Self { path: Default::default() }
7381 }
7382 #[doc(hidden)]
7383 pub fn new_with_base(base: Vec<&'static str>) -> Self {
7384 Self { path: base }
7385 }
7386 pub fn finish(self) -> String {
7387 self.path.join(".")
7388 }
7389 pub fn scheme(mut self) -> String {
7390 self.path.push(MultisigMemberSignature::SCHEME_FIELD.name);
7391 self.finish()
7392 }
7393 pub fn signature(mut self) -> String {
7394 self.path.push(MultisigMemberSignature::SIGNATURE_FIELD.name);
7395 self.finish()
7396 }
7397 pub fn zklogin(mut self) -> ZkLoginAuthenticatorFieldPathBuilder {
7398 self.path.push(MultisigMemberSignature::ZKLOGIN_FIELD.name);
7399 ZkLoginAuthenticatorFieldPathBuilder::new_with_base(self.path)
7400 }
7401 pub fn passkey(mut self) -> PasskeyAuthenticatorFieldPathBuilder {
7402 self.path.push(MultisigMemberSignature::PASSKEY_FIELD.name);
7403 PasskeyAuthenticatorFieldPathBuilder::new_with_base(self.path)
7404 }
7405 }
7406 impl ZkLoginAuthenticator {
7407 pub const INPUTS_FIELD: &'static MessageField = &MessageField {
7408 name: "inputs",
7409 json_name: "inputs",
7410 number: 1i32,
7411 message_fields: Some(ZkLoginInputs::FIELDS),
7412 };
7413 pub const MAX_EPOCH_FIELD: &'static MessageField = &MessageField {
7414 name: "max_epoch",
7415 json_name: "maxEpoch",
7416 number: 2i32,
7417 message_fields: None,
7418 };
7419 pub const SIGNATURE_FIELD: &'static MessageField = &MessageField {
7420 name: "signature",
7421 json_name: "signature",
7422 number: 3i32,
7423 message_fields: Some(SimpleSignature::FIELDS),
7424 };
7425 pub const PUBLIC_IDENTIFIER_FIELD: &'static MessageField = &MessageField {
7426 name: "public_identifier",
7427 json_name: "publicIdentifier",
7428 number: 4i32,
7429 message_fields: Some(ZkLoginPublicIdentifier::FIELDS),
7430 };
7431 pub const JWK_ID_FIELD: &'static MessageField = &MessageField {
7432 name: "jwk_id",
7433 json_name: "jwkId",
7434 number: 5i32,
7435 message_fields: Some(JwkId::FIELDS),
7436 };
7437 }
7438 impl MessageFields for ZkLoginAuthenticator {
7439 const FIELDS: &'static [&'static MessageField] = &[
7440 Self::INPUTS_FIELD,
7441 Self::MAX_EPOCH_FIELD,
7442 Self::SIGNATURE_FIELD,
7443 Self::PUBLIC_IDENTIFIER_FIELD,
7444 Self::JWK_ID_FIELD,
7445 ];
7446 }
7447 impl ZkLoginAuthenticator {
7448 pub fn path_builder() -> ZkLoginAuthenticatorFieldPathBuilder {
7449 ZkLoginAuthenticatorFieldPathBuilder::new()
7450 }
7451 }
7452 pub struct ZkLoginAuthenticatorFieldPathBuilder {
7453 path: Vec<&'static str>,
7454 }
7455 impl ZkLoginAuthenticatorFieldPathBuilder {
7456 #[allow(clippy::new_without_default)]
7457 pub fn new() -> Self {
7458 Self { path: Default::default() }
7459 }
7460 #[doc(hidden)]
7461 pub fn new_with_base(base: Vec<&'static str>) -> Self {
7462 Self { path: base }
7463 }
7464 pub fn finish(self) -> String {
7465 self.path.join(".")
7466 }
7467 pub fn inputs(mut self) -> ZkLoginInputsFieldPathBuilder {
7468 self.path.push(ZkLoginAuthenticator::INPUTS_FIELD.name);
7469 ZkLoginInputsFieldPathBuilder::new_with_base(self.path)
7470 }
7471 pub fn max_epoch(mut self) -> String {
7472 self.path.push(ZkLoginAuthenticator::MAX_EPOCH_FIELD.name);
7473 self.finish()
7474 }
7475 pub fn signature(mut self) -> SimpleSignatureFieldPathBuilder {
7476 self.path.push(ZkLoginAuthenticator::SIGNATURE_FIELD.name);
7477 SimpleSignatureFieldPathBuilder::new_with_base(self.path)
7478 }
7479 pub fn public_identifier(mut self) -> ZkLoginPublicIdentifierFieldPathBuilder {
7480 self.path.push(ZkLoginAuthenticator::PUBLIC_IDENTIFIER_FIELD.name);
7481 ZkLoginPublicIdentifierFieldPathBuilder::new_with_base(self.path)
7482 }
7483 pub fn jwk_id(mut self) -> JwkIdFieldPathBuilder {
7484 self.path.push(ZkLoginAuthenticator::JWK_ID_FIELD.name);
7485 JwkIdFieldPathBuilder::new_with_base(self.path)
7486 }
7487 }
7488 impl ZkLoginInputs {
7489 pub const PROOF_POINTS_FIELD: &'static MessageField = &MessageField {
7490 name: "proof_points",
7491 json_name: "proofPoints",
7492 number: 1i32,
7493 message_fields: Some(ZkLoginProof::FIELDS),
7494 };
7495 pub const ISS_BASE64_DETAILS_FIELD: &'static MessageField = &MessageField {
7496 name: "iss_base64_details",
7497 json_name: "issBase64Details",
7498 number: 2i32,
7499 message_fields: Some(ZkLoginClaim::FIELDS),
7500 };
7501 pub const HEADER_BASE64_FIELD: &'static MessageField = &MessageField {
7502 name: "header_base64",
7503 json_name: "headerBase64",
7504 number: 3i32,
7505 message_fields: None,
7506 };
7507 pub const ADDRESS_SEED_FIELD: &'static MessageField = &MessageField {
7508 name: "address_seed",
7509 json_name: "addressSeed",
7510 number: 4i32,
7511 message_fields: None,
7512 };
7513 }
7514 impl MessageFields for ZkLoginInputs {
7515 const FIELDS: &'static [&'static MessageField] = &[
7516 Self::PROOF_POINTS_FIELD,
7517 Self::ISS_BASE64_DETAILS_FIELD,
7518 Self::HEADER_BASE64_FIELD,
7519 Self::ADDRESS_SEED_FIELD,
7520 ];
7521 }
7522 impl ZkLoginInputs {
7523 pub fn path_builder() -> ZkLoginInputsFieldPathBuilder {
7524 ZkLoginInputsFieldPathBuilder::new()
7525 }
7526 }
7527 pub struct ZkLoginInputsFieldPathBuilder {
7528 path: Vec<&'static str>,
7529 }
7530 impl ZkLoginInputsFieldPathBuilder {
7531 #[allow(clippy::new_without_default)]
7532 pub fn new() -> Self {
7533 Self { path: Default::default() }
7534 }
7535 #[doc(hidden)]
7536 pub fn new_with_base(base: Vec<&'static str>) -> Self {
7537 Self { path: base }
7538 }
7539 pub fn finish(self) -> String {
7540 self.path.join(".")
7541 }
7542 pub fn proof_points(mut self) -> ZkLoginProofFieldPathBuilder {
7543 self.path.push(ZkLoginInputs::PROOF_POINTS_FIELD.name);
7544 ZkLoginProofFieldPathBuilder::new_with_base(self.path)
7545 }
7546 pub fn iss_base64_details(mut self) -> ZkLoginClaimFieldPathBuilder {
7547 self.path.push(ZkLoginInputs::ISS_BASE64_DETAILS_FIELD.name);
7548 ZkLoginClaimFieldPathBuilder::new_with_base(self.path)
7549 }
7550 pub fn header_base64(mut self) -> String {
7551 self.path.push(ZkLoginInputs::HEADER_BASE64_FIELD.name);
7552 self.finish()
7553 }
7554 pub fn address_seed(mut self) -> String {
7555 self.path.push(ZkLoginInputs::ADDRESS_SEED_FIELD.name);
7556 self.finish()
7557 }
7558 }
7559 impl ZkLoginProof {
7560 pub const A_FIELD: &'static MessageField = &MessageField {
7561 name: "a",
7562 json_name: "a",
7563 number: 1i32,
7564 message_fields: Some(CircomG1::FIELDS),
7565 };
7566 pub const B_FIELD: &'static MessageField = &MessageField {
7567 name: "b",
7568 json_name: "b",
7569 number: 2i32,
7570 message_fields: Some(CircomG2::FIELDS),
7571 };
7572 pub const C_FIELD: &'static MessageField = &MessageField {
7573 name: "c",
7574 json_name: "c",
7575 number: 3i32,
7576 message_fields: Some(CircomG1::FIELDS),
7577 };
7578 }
7579 impl MessageFields for ZkLoginProof {
7580 const FIELDS: &'static [&'static MessageField] = &[
7581 Self::A_FIELD,
7582 Self::B_FIELD,
7583 Self::C_FIELD,
7584 ];
7585 }
7586 impl ZkLoginProof {
7587 pub fn path_builder() -> ZkLoginProofFieldPathBuilder {
7588 ZkLoginProofFieldPathBuilder::new()
7589 }
7590 }
7591 pub struct ZkLoginProofFieldPathBuilder {
7592 path: Vec<&'static str>,
7593 }
7594 impl ZkLoginProofFieldPathBuilder {
7595 #[allow(clippy::new_without_default)]
7596 pub fn new() -> Self {
7597 Self { path: Default::default() }
7598 }
7599 #[doc(hidden)]
7600 pub fn new_with_base(base: Vec<&'static str>) -> Self {
7601 Self { path: base }
7602 }
7603 pub fn finish(self) -> String {
7604 self.path.join(".")
7605 }
7606 pub fn a(mut self) -> CircomG1FieldPathBuilder {
7607 self.path.push(ZkLoginProof::A_FIELD.name);
7608 CircomG1FieldPathBuilder::new_with_base(self.path)
7609 }
7610 pub fn b(mut self) -> CircomG2FieldPathBuilder {
7611 self.path.push(ZkLoginProof::B_FIELD.name);
7612 CircomG2FieldPathBuilder::new_with_base(self.path)
7613 }
7614 pub fn c(mut self) -> CircomG1FieldPathBuilder {
7615 self.path.push(ZkLoginProof::C_FIELD.name);
7616 CircomG1FieldPathBuilder::new_with_base(self.path)
7617 }
7618 }
7619 impl ZkLoginClaim {
7620 pub const VALUE_FIELD: &'static MessageField = &MessageField {
7621 name: "value",
7622 json_name: "value",
7623 number: 1i32,
7624 message_fields: None,
7625 };
7626 pub const INDEX_MOD_4_FIELD: &'static MessageField = &MessageField {
7627 name: "index_mod_4",
7628 json_name: "indexMod4",
7629 number: 2i32,
7630 message_fields: None,
7631 };
7632 }
7633 impl MessageFields for ZkLoginClaim {
7634 const FIELDS: &'static [&'static MessageField] = &[
7635 Self::VALUE_FIELD,
7636 Self::INDEX_MOD_4_FIELD,
7637 ];
7638 }
7639 impl ZkLoginClaim {
7640 pub fn path_builder() -> ZkLoginClaimFieldPathBuilder {
7641 ZkLoginClaimFieldPathBuilder::new()
7642 }
7643 }
7644 pub struct ZkLoginClaimFieldPathBuilder {
7645 path: Vec<&'static str>,
7646 }
7647 impl ZkLoginClaimFieldPathBuilder {
7648 #[allow(clippy::new_without_default)]
7649 pub fn new() -> Self {
7650 Self { path: Default::default() }
7651 }
7652 #[doc(hidden)]
7653 pub fn new_with_base(base: Vec<&'static str>) -> Self {
7654 Self { path: base }
7655 }
7656 pub fn finish(self) -> String {
7657 self.path.join(".")
7658 }
7659 pub fn value(mut self) -> String {
7660 self.path.push(ZkLoginClaim::VALUE_FIELD.name);
7661 self.finish()
7662 }
7663 pub fn index_mod_4(mut self) -> String {
7664 self.path.push(ZkLoginClaim::INDEX_MOD_4_FIELD.name);
7665 self.finish()
7666 }
7667 }
7668 impl CircomG1 {
7669 pub const E0_FIELD: &'static MessageField = &MessageField {
7670 name: "e0",
7671 json_name: "e0",
7672 number: 1i32,
7673 message_fields: None,
7674 };
7675 pub const E1_FIELD: &'static MessageField = &MessageField {
7676 name: "e1",
7677 json_name: "e1",
7678 number: 2i32,
7679 message_fields: None,
7680 };
7681 pub const E2_FIELD: &'static MessageField = &MessageField {
7682 name: "e2",
7683 json_name: "e2",
7684 number: 3i32,
7685 message_fields: None,
7686 };
7687 }
7688 impl MessageFields for CircomG1 {
7689 const FIELDS: &'static [&'static MessageField] = &[
7690 Self::E0_FIELD,
7691 Self::E1_FIELD,
7692 Self::E2_FIELD,
7693 ];
7694 }
7695 impl CircomG1 {
7696 pub fn path_builder() -> CircomG1FieldPathBuilder {
7697 CircomG1FieldPathBuilder::new()
7698 }
7699 }
7700 pub struct CircomG1FieldPathBuilder {
7701 path: Vec<&'static str>,
7702 }
7703 impl CircomG1FieldPathBuilder {
7704 #[allow(clippy::new_without_default)]
7705 pub fn new() -> Self {
7706 Self { path: Default::default() }
7707 }
7708 #[doc(hidden)]
7709 pub fn new_with_base(base: Vec<&'static str>) -> Self {
7710 Self { path: base }
7711 }
7712 pub fn finish(self) -> String {
7713 self.path.join(".")
7714 }
7715 pub fn e0(mut self) -> String {
7716 self.path.push(CircomG1::E0_FIELD.name);
7717 self.finish()
7718 }
7719 pub fn e1(mut self) -> String {
7720 self.path.push(CircomG1::E1_FIELD.name);
7721 self.finish()
7722 }
7723 pub fn e2(mut self) -> String {
7724 self.path.push(CircomG1::E2_FIELD.name);
7725 self.finish()
7726 }
7727 }
7728 impl CircomG2 {
7729 pub const E00_FIELD: &'static MessageField = &MessageField {
7730 name: "e00",
7731 json_name: "e00",
7732 number: 1i32,
7733 message_fields: None,
7734 };
7735 pub const E01_FIELD: &'static MessageField = &MessageField {
7736 name: "e01",
7737 json_name: "e01",
7738 number: 2i32,
7739 message_fields: None,
7740 };
7741 pub const E10_FIELD: &'static MessageField = &MessageField {
7742 name: "e10",
7743 json_name: "e10",
7744 number: 3i32,
7745 message_fields: None,
7746 };
7747 pub const E11_FIELD: &'static MessageField = &MessageField {
7748 name: "e11",
7749 json_name: "e11",
7750 number: 4i32,
7751 message_fields: None,
7752 };
7753 pub const E20_FIELD: &'static MessageField = &MessageField {
7754 name: "e20",
7755 json_name: "e20",
7756 number: 5i32,
7757 message_fields: None,
7758 };
7759 pub const E21_FIELD: &'static MessageField = &MessageField {
7760 name: "e21",
7761 json_name: "e21",
7762 number: 6i32,
7763 message_fields: None,
7764 };
7765 }
7766 impl MessageFields for CircomG2 {
7767 const FIELDS: &'static [&'static MessageField] = &[
7768 Self::E00_FIELD,
7769 Self::E01_FIELD,
7770 Self::E10_FIELD,
7771 Self::E11_FIELD,
7772 Self::E20_FIELD,
7773 Self::E21_FIELD,
7774 ];
7775 }
7776 impl CircomG2 {
7777 pub fn path_builder() -> CircomG2FieldPathBuilder {
7778 CircomG2FieldPathBuilder::new()
7779 }
7780 }
7781 pub struct CircomG2FieldPathBuilder {
7782 path: Vec<&'static str>,
7783 }
7784 impl CircomG2FieldPathBuilder {
7785 #[allow(clippy::new_without_default)]
7786 pub fn new() -> Self {
7787 Self { path: Default::default() }
7788 }
7789 #[doc(hidden)]
7790 pub fn new_with_base(base: Vec<&'static str>) -> Self {
7791 Self { path: base }
7792 }
7793 pub fn finish(self) -> String {
7794 self.path.join(".")
7795 }
7796 pub fn e00(mut self) -> String {
7797 self.path.push(CircomG2::E00_FIELD.name);
7798 self.finish()
7799 }
7800 pub fn e01(mut self) -> String {
7801 self.path.push(CircomG2::E01_FIELD.name);
7802 self.finish()
7803 }
7804 pub fn e10(mut self) -> String {
7805 self.path.push(CircomG2::E10_FIELD.name);
7806 self.finish()
7807 }
7808 pub fn e11(mut self) -> String {
7809 self.path.push(CircomG2::E11_FIELD.name);
7810 self.finish()
7811 }
7812 pub fn e20(mut self) -> String {
7813 self.path.push(CircomG2::E20_FIELD.name);
7814 self.finish()
7815 }
7816 pub fn e21(mut self) -> String {
7817 self.path.push(CircomG2::E21_FIELD.name);
7818 self.finish()
7819 }
7820 }
7821 impl PasskeyAuthenticator {
7822 pub const AUTHENTICATOR_DATA_FIELD: &'static MessageField = &MessageField {
7823 name: "authenticator_data",
7824 json_name: "authenticatorData",
7825 number: 1i32,
7826 message_fields: None,
7827 };
7828 pub const CLIENT_DATA_JSON_FIELD: &'static MessageField = &MessageField {
7829 name: "client_data_json",
7830 json_name: "clientDataJson",
7831 number: 2i32,
7832 message_fields: None,
7833 };
7834 pub const SIGNATURE_FIELD: &'static MessageField = &MessageField {
7835 name: "signature",
7836 json_name: "signature",
7837 number: 3i32,
7838 message_fields: Some(SimpleSignature::FIELDS),
7839 };
7840 }
7841 impl MessageFields for PasskeyAuthenticator {
7842 const FIELDS: &'static [&'static MessageField] = &[
7843 Self::AUTHENTICATOR_DATA_FIELD,
7844 Self::CLIENT_DATA_JSON_FIELD,
7845 Self::SIGNATURE_FIELD,
7846 ];
7847 }
7848 impl PasskeyAuthenticator {
7849 pub fn path_builder() -> PasskeyAuthenticatorFieldPathBuilder {
7850 PasskeyAuthenticatorFieldPathBuilder::new()
7851 }
7852 }
7853 pub struct PasskeyAuthenticatorFieldPathBuilder {
7854 path: Vec<&'static str>,
7855 }
7856 impl PasskeyAuthenticatorFieldPathBuilder {
7857 #[allow(clippy::new_without_default)]
7858 pub fn new() -> Self {
7859 Self { path: Default::default() }
7860 }
7861 #[doc(hidden)]
7862 pub fn new_with_base(base: Vec<&'static str>) -> Self {
7863 Self { path: base }
7864 }
7865 pub fn finish(self) -> String {
7866 self.path.join(".")
7867 }
7868 pub fn authenticator_data(mut self) -> String {
7869 self.path.push(PasskeyAuthenticator::AUTHENTICATOR_DATA_FIELD.name);
7870 self.finish()
7871 }
7872 pub fn client_data_json(mut self) -> String {
7873 self.path.push(PasskeyAuthenticator::CLIENT_DATA_JSON_FIELD.name);
7874 self.finish()
7875 }
7876 pub fn signature(mut self) -> SimpleSignatureFieldPathBuilder {
7877 self.path.push(PasskeyAuthenticator::SIGNATURE_FIELD.name);
7878 SimpleSignatureFieldPathBuilder::new_with_base(self.path)
7879 }
7880 }
7881 impl ValidatorCommittee {
7882 pub const EPOCH_FIELD: &'static MessageField = &MessageField {
7883 name: "epoch",
7884 json_name: "epoch",
7885 number: 1i32,
7886 message_fields: None,
7887 };
7888 pub const MEMBERS_FIELD: &'static MessageField = &MessageField {
7889 name: "members",
7890 json_name: "members",
7891 number: 2i32,
7892 message_fields: Some(ValidatorCommitteeMember::FIELDS),
7893 };
7894 }
7895 impl MessageFields for ValidatorCommittee {
7896 const FIELDS: &'static [&'static MessageField] = &[
7897 Self::EPOCH_FIELD,
7898 Self::MEMBERS_FIELD,
7899 ];
7900 }
7901 impl ValidatorCommittee {
7902 pub fn path_builder() -> ValidatorCommitteeFieldPathBuilder {
7903 ValidatorCommitteeFieldPathBuilder::new()
7904 }
7905 }
7906 pub struct ValidatorCommitteeFieldPathBuilder {
7907 path: Vec<&'static str>,
7908 }
7909 impl ValidatorCommitteeFieldPathBuilder {
7910 #[allow(clippy::new_without_default)]
7911 pub fn new() -> Self {
7912 Self { path: Default::default() }
7913 }
7914 #[doc(hidden)]
7915 pub fn new_with_base(base: Vec<&'static str>) -> Self {
7916 Self { path: base }
7917 }
7918 pub fn finish(self) -> String {
7919 self.path.join(".")
7920 }
7921 pub fn epoch(mut self) -> String {
7922 self.path.push(ValidatorCommittee::EPOCH_FIELD.name);
7923 self.finish()
7924 }
7925 pub fn members(mut self) -> ValidatorCommitteeMemberFieldPathBuilder {
7926 self.path.push(ValidatorCommittee::MEMBERS_FIELD.name);
7927 ValidatorCommitteeMemberFieldPathBuilder::new_with_base(self.path)
7928 }
7929 }
7930 impl ValidatorCommitteeMember {
7931 pub const PUBLIC_KEY_FIELD: &'static MessageField = &MessageField {
7932 name: "public_key",
7933 json_name: "publicKey",
7934 number: 1i32,
7935 message_fields: None,
7936 };
7937 pub const WEIGHT_FIELD: &'static MessageField = &MessageField {
7938 name: "weight",
7939 json_name: "weight",
7940 number: 2i32,
7941 message_fields: None,
7942 };
7943 }
7944 impl MessageFields for ValidatorCommitteeMember {
7945 const FIELDS: &'static [&'static MessageField] = &[
7946 Self::PUBLIC_KEY_FIELD,
7947 Self::WEIGHT_FIELD,
7948 ];
7949 }
7950 impl ValidatorCommitteeMember {
7951 pub fn path_builder() -> ValidatorCommitteeMemberFieldPathBuilder {
7952 ValidatorCommitteeMemberFieldPathBuilder::new()
7953 }
7954 }
7955 pub struct ValidatorCommitteeMemberFieldPathBuilder {
7956 path: Vec<&'static str>,
7957 }
7958 impl ValidatorCommitteeMemberFieldPathBuilder {
7959 #[allow(clippy::new_without_default)]
7960 pub fn new() -> Self {
7961 Self { path: Default::default() }
7962 }
7963 #[doc(hidden)]
7964 pub fn new_with_base(base: Vec<&'static str>) -> Self {
7965 Self { path: base }
7966 }
7967 pub fn finish(self) -> String {
7968 self.path.join(".")
7969 }
7970 pub fn public_key(mut self) -> String {
7971 self.path.push(ValidatorCommitteeMember::PUBLIC_KEY_FIELD.name);
7972 self.finish()
7973 }
7974 pub fn weight(mut self) -> String {
7975 self.path.push(ValidatorCommitteeMember::WEIGHT_FIELD.name);
7976 self.finish()
7977 }
7978 }
7979 impl ValidatorAggregatedSignature {
7980 pub const EPOCH_FIELD: &'static MessageField = &MessageField {
7981 name: "epoch",
7982 json_name: "epoch",
7983 number: 1i32,
7984 message_fields: None,
7985 };
7986 pub const SIGNATURE_FIELD: &'static MessageField = &MessageField {
7987 name: "signature",
7988 json_name: "signature",
7989 number: 2i32,
7990 message_fields: None,
7991 };
7992 pub const BITMAP_FIELD: &'static MessageField = &MessageField {
7993 name: "bitmap",
7994 json_name: "bitmap",
7995 number: 3i32,
7996 message_fields: None,
7997 };
7998 }
7999 impl MessageFields for ValidatorAggregatedSignature {
8000 const FIELDS: &'static [&'static MessageField] = &[
8001 Self::EPOCH_FIELD,
8002 Self::SIGNATURE_FIELD,
8003 Self::BITMAP_FIELD,
8004 ];
8005 }
8006 impl ValidatorAggregatedSignature {
8007 pub fn path_builder() -> ValidatorAggregatedSignatureFieldPathBuilder {
8008 ValidatorAggregatedSignatureFieldPathBuilder::new()
8009 }
8010 }
8011 pub struct ValidatorAggregatedSignatureFieldPathBuilder {
8012 path: Vec<&'static str>,
8013 }
8014 impl ValidatorAggregatedSignatureFieldPathBuilder {
8015 #[allow(clippy::new_without_default)]
8016 pub fn new() -> Self {
8017 Self { path: Default::default() }
8018 }
8019 #[doc(hidden)]
8020 pub fn new_with_base(base: Vec<&'static str>) -> Self {
8021 Self { path: base }
8022 }
8023 pub fn finish(self) -> String {
8024 self.path.join(".")
8025 }
8026 pub fn epoch(mut self) -> String {
8027 self.path.push(ValidatorAggregatedSignature::EPOCH_FIELD.name);
8028 self.finish()
8029 }
8030 pub fn signature(mut self) -> String {
8031 self.path.push(ValidatorAggregatedSignature::SIGNATURE_FIELD.name);
8032 self.finish()
8033 }
8034 pub fn bitmap(mut self) -> String {
8035 self.path.push(ValidatorAggregatedSignature::BITMAP_FIELD.name);
8036 self.finish()
8037 }
8038 }
8039 impl VerifySignatureRequest {
8040 pub const MESSAGE_FIELD: &'static MessageField = &MessageField {
8041 name: "message",
8042 json_name: "message",
8043 number: 1i32,
8044 message_fields: Some(Bcs::FIELDS),
8045 };
8046 pub const SIGNATURE_FIELD: &'static MessageField = &MessageField {
8047 name: "signature",
8048 json_name: "signature",
8049 number: 2i32,
8050 message_fields: Some(UserSignature::FIELDS),
8051 };
8052 pub const ADDRESS_FIELD: &'static MessageField = &MessageField {
8053 name: "address",
8054 json_name: "address",
8055 number: 3i32,
8056 message_fields: None,
8057 };
8058 pub const JWKS_FIELD: &'static MessageField = &MessageField {
8059 name: "jwks",
8060 json_name: "jwks",
8061 number: 4i32,
8062 message_fields: Some(ActiveJwk::FIELDS),
8063 };
8064 }
8065 impl MessageFields for VerifySignatureRequest {
8066 const FIELDS: &'static [&'static MessageField] = &[
8067 Self::MESSAGE_FIELD,
8068 Self::SIGNATURE_FIELD,
8069 Self::ADDRESS_FIELD,
8070 Self::JWKS_FIELD,
8071 ];
8072 }
8073 impl VerifySignatureRequest {
8074 pub fn path_builder() -> VerifySignatureRequestFieldPathBuilder {
8075 VerifySignatureRequestFieldPathBuilder::new()
8076 }
8077 }
8078 pub struct VerifySignatureRequestFieldPathBuilder {
8079 path: Vec<&'static str>,
8080 }
8081 impl VerifySignatureRequestFieldPathBuilder {
8082 #[allow(clippy::new_without_default)]
8083 pub fn new() -> Self {
8084 Self { path: Default::default() }
8085 }
8086 #[doc(hidden)]
8087 pub fn new_with_base(base: Vec<&'static str>) -> Self {
8088 Self { path: base }
8089 }
8090 pub fn finish(self) -> String {
8091 self.path.join(".")
8092 }
8093 pub fn message(mut self) -> BcsFieldPathBuilder {
8094 self.path.push(VerifySignatureRequest::MESSAGE_FIELD.name);
8095 BcsFieldPathBuilder::new_with_base(self.path)
8096 }
8097 pub fn signature(mut self) -> UserSignatureFieldPathBuilder {
8098 self.path.push(VerifySignatureRequest::SIGNATURE_FIELD.name);
8099 UserSignatureFieldPathBuilder::new_with_base(self.path)
8100 }
8101 pub fn address(mut self) -> String {
8102 self.path.push(VerifySignatureRequest::ADDRESS_FIELD.name);
8103 self.finish()
8104 }
8105 pub fn jwks(mut self) -> ActiveJwkFieldPathBuilder {
8106 self.path.push(VerifySignatureRequest::JWKS_FIELD.name);
8107 ActiveJwkFieldPathBuilder::new_with_base(self.path)
8108 }
8109 }
8110 impl VerifySignatureResponse {
8111 pub const IS_VALID_FIELD: &'static MessageField = &MessageField {
8112 name: "is_valid",
8113 json_name: "isValid",
8114 number: 1i32,
8115 message_fields: None,
8116 };
8117 pub const REASON_FIELD: &'static MessageField = &MessageField {
8118 name: "reason",
8119 json_name: "reason",
8120 number: 2i32,
8121 message_fields: None,
8122 };
8123 }
8124 impl MessageFields for VerifySignatureResponse {
8125 const FIELDS: &'static [&'static MessageField] = &[
8126 Self::IS_VALID_FIELD,
8127 Self::REASON_FIELD,
8128 ];
8129 }
8130 impl VerifySignatureResponse {
8131 pub fn path_builder() -> VerifySignatureResponseFieldPathBuilder {
8132 VerifySignatureResponseFieldPathBuilder::new()
8133 }
8134 }
8135 pub struct VerifySignatureResponseFieldPathBuilder {
8136 path: Vec<&'static str>,
8137 }
8138 impl VerifySignatureResponseFieldPathBuilder {
8139 #[allow(clippy::new_without_default)]
8140 pub fn new() -> Self {
8141 Self { path: Default::default() }
8142 }
8143 #[doc(hidden)]
8144 pub fn new_with_base(base: Vec<&'static str>) -> Self {
8145 Self { path: base }
8146 }
8147 pub fn finish(self) -> String {
8148 self.path.join(".")
8149 }
8150 pub fn is_valid(mut self) -> String {
8151 self.path.push(VerifySignatureResponse::IS_VALID_FIELD.name);
8152 self.finish()
8153 }
8154 pub fn reason(mut self) -> String {
8155 self.path.push(VerifySignatureResponse::REASON_FIELD.name);
8156 self.finish()
8157 }
8158 }
8159 impl GetCoinInfoRequest {
8160 pub const COIN_TYPE_FIELD: &'static MessageField = &MessageField {
8161 name: "coin_type",
8162 json_name: "coinType",
8163 number: 1i32,
8164 message_fields: None,
8165 };
8166 }
8167 impl MessageFields for GetCoinInfoRequest {
8168 const FIELDS: &'static [&'static MessageField] = &[Self::COIN_TYPE_FIELD];
8169 }
8170 impl GetCoinInfoRequest {
8171 pub fn path_builder() -> GetCoinInfoRequestFieldPathBuilder {
8172 GetCoinInfoRequestFieldPathBuilder::new()
8173 }
8174 }
8175 pub struct GetCoinInfoRequestFieldPathBuilder {
8176 path: Vec<&'static str>,
8177 }
8178 impl GetCoinInfoRequestFieldPathBuilder {
8179 #[allow(clippy::new_without_default)]
8180 pub fn new() -> Self {
8181 Self { path: Default::default() }
8182 }
8183 #[doc(hidden)]
8184 pub fn new_with_base(base: Vec<&'static str>) -> Self {
8185 Self { path: base }
8186 }
8187 pub fn finish(self) -> String {
8188 self.path.join(".")
8189 }
8190 pub fn coin_type(mut self) -> String {
8191 self.path.push(GetCoinInfoRequest::COIN_TYPE_FIELD.name);
8192 self.finish()
8193 }
8194 }
8195 impl GetCoinInfoResponse {
8196 pub const COIN_TYPE_FIELD: &'static MessageField = &MessageField {
8197 name: "coin_type",
8198 json_name: "coinType",
8199 number: 1i32,
8200 message_fields: None,
8201 };
8202 pub const METADATA_FIELD: &'static MessageField = &MessageField {
8203 name: "metadata",
8204 json_name: "metadata",
8205 number: 2i32,
8206 message_fields: Some(CoinMetadata::FIELDS),
8207 };
8208 pub const TREASURY_FIELD: &'static MessageField = &MessageField {
8209 name: "treasury",
8210 json_name: "treasury",
8211 number: 3i32,
8212 message_fields: Some(CoinTreasury::FIELDS),
8213 };
8214 pub const REGULATED_METADATA_FIELD: &'static MessageField = &MessageField {
8215 name: "regulated_metadata",
8216 json_name: "regulatedMetadata",
8217 number: 4i32,
8218 message_fields: Some(RegulatedCoinMetadata::FIELDS),
8219 };
8220 }
8221 impl MessageFields for GetCoinInfoResponse {
8222 const FIELDS: &'static [&'static MessageField] = &[
8223 Self::COIN_TYPE_FIELD,
8224 Self::METADATA_FIELD,
8225 Self::TREASURY_FIELD,
8226 Self::REGULATED_METADATA_FIELD,
8227 ];
8228 }
8229 impl GetCoinInfoResponse {
8230 pub fn path_builder() -> GetCoinInfoResponseFieldPathBuilder {
8231 GetCoinInfoResponseFieldPathBuilder::new()
8232 }
8233 }
8234 pub struct GetCoinInfoResponseFieldPathBuilder {
8235 path: Vec<&'static str>,
8236 }
8237 impl GetCoinInfoResponseFieldPathBuilder {
8238 #[allow(clippy::new_without_default)]
8239 pub fn new() -> Self {
8240 Self { path: Default::default() }
8241 }
8242 #[doc(hidden)]
8243 pub fn new_with_base(base: Vec<&'static str>) -> Self {
8244 Self { path: base }
8245 }
8246 pub fn finish(self) -> String {
8247 self.path.join(".")
8248 }
8249 pub fn coin_type(mut self) -> String {
8250 self.path.push(GetCoinInfoResponse::COIN_TYPE_FIELD.name);
8251 self.finish()
8252 }
8253 pub fn metadata(mut self) -> CoinMetadataFieldPathBuilder {
8254 self.path.push(GetCoinInfoResponse::METADATA_FIELD.name);
8255 CoinMetadataFieldPathBuilder::new_with_base(self.path)
8256 }
8257 pub fn treasury(mut self) -> CoinTreasuryFieldPathBuilder {
8258 self.path.push(GetCoinInfoResponse::TREASURY_FIELD.name);
8259 CoinTreasuryFieldPathBuilder::new_with_base(self.path)
8260 }
8261 pub fn regulated_metadata(mut self) -> RegulatedCoinMetadataFieldPathBuilder {
8262 self.path.push(GetCoinInfoResponse::REGULATED_METADATA_FIELD.name);
8263 RegulatedCoinMetadataFieldPathBuilder::new_with_base(self.path)
8264 }
8265 }
8266 impl CoinMetadata {
8267 pub const ID_FIELD: &'static MessageField = &MessageField {
8268 name: "id",
8269 json_name: "id",
8270 number: 1i32,
8271 message_fields: None,
8272 };
8273 pub const DECIMALS_FIELD: &'static MessageField = &MessageField {
8274 name: "decimals",
8275 json_name: "decimals",
8276 number: 2i32,
8277 message_fields: None,
8278 };
8279 pub const NAME_FIELD: &'static MessageField = &MessageField {
8280 name: "name",
8281 json_name: "name",
8282 number: 3i32,
8283 message_fields: None,
8284 };
8285 pub const SYMBOL_FIELD: &'static MessageField = &MessageField {
8286 name: "symbol",
8287 json_name: "symbol",
8288 number: 4i32,
8289 message_fields: None,
8290 };
8291 pub const DESCRIPTION_FIELD: &'static MessageField = &MessageField {
8292 name: "description",
8293 json_name: "description",
8294 number: 5i32,
8295 message_fields: None,
8296 };
8297 pub const ICON_URL_FIELD: &'static MessageField = &MessageField {
8298 name: "icon_url",
8299 json_name: "iconUrl",
8300 number: 6i32,
8301 message_fields: None,
8302 };
8303 pub const METADATA_CAP_ID_FIELD: &'static MessageField = &MessageField {
8304 name: "metadata_cap_id",
8305 json_name: "metadataCapId",
8306 number: 7i32,
8307 message_fields: None,
8308 };
8309 pub const METADATA_CAP_STATE_FIELD: &'static MessageField = &MessageField {
8310 name: "metadata_cap_state",
8311 json_name: "metadataCapState",
8312 number: 8i32,
8313 message_fields: None,
8314 };
8315 }
8316 impl MessageFields for CoinMetadata {
8317 const FIELDS: &'static [&'static MessageField] = &[
8318 Self::ID_FIELD,
8319 Self::DECIMALS_FIELD,
8320 Self::NAME_FIELD,
8321 Self::SYMBOL_FIELD,
8322 Self::DESCRIPTION_FIELD,
8323 Self::ICON_URL_FIELD,
8324 Self::METADATA_CAP_ID_FIELD,
8325 Self::METADATA_CAP_STATE_FIELD,
8326 ];
8327 }
8328 impl CoinMetadata {
8329 pub fn path_builder() -> CoinMetadataFieldPathBuilder {
8330 CoinMetadataFieldPathBuilder::new()
8331 }
8332 }
8333 pub struct CoinMetadataFieldPathBuilder {
8334 path: Vec<&'static str>,
8335 }
8336 impl CoinMetadataFieldPathBuilder {
8337 #[allow(clippy::new_without_default)]
8338 pub fn new() -> Self {
8339 Self { path: Default::default() }
8340 }
8341 #[doc(hidden)]
8342 pub fn new_with_base(base: Vec<&'static str>) -> Self {
8343 Self { path: base }
8344 }
8345 pub fn finish(self) -> String {
8346 self.path.join(".")
8347 }
8348 pub fn id(mut self) -> String {
8349 self.path.push(CoinMetadata::ID_FIELD.name);
8350 self.finish()
8351 }
8352 pub fn decimals(mut self) -> String {
8353 self.path.push(CoinMetadata::DECIMALS_FIELD.name);
8354 self.finish()
8355 }
8356 pub fn name(mut self) -> String {
8357 self.path.push(CoinMetadata::NAME_FIELD.name);
8358 self.finish()
8359 }
8360 pub fn symbol(mut self) -> String {
8361 self.path.push(CoinMetadata::SYMBOL_FIELD.name);
8362 self.finish()
8363 }
8364 pub fn description(mut self) -> String {
8365 self.path.push(CoinMetadata::DESCRIPTION_FIELD.name);
8366 self.finish()
8367 }
8368 pub fn icon_url(mut self) -> String {
8369 self.path.push(CoinMetadata::ICON_URL_FIELD.name);
8370 self.finish()
8371 }
8372 pub fn metadata_cap_id(mut self) -> String {
8373 self.path.push(CoinMetadata::METADATA_CAP_ID_FIELD.name);
8374 self.finish()
8375 }
8376 pub fn metadata_cap_state(mut self) -> String {
8377 self.path.push(CoinMetadata::METADATA_CAP_STATE_FIELD.name);
8378 self.finish()
8379 }
8380 }
8381 impl CoinTreasury {
8382 pub const ID_FIELD: &'static MessageField = &MessageField {
8383 name: "id",
8384 json_name: "id",
8385 number: 1i32,
8386 message_fields: None,
8387 };
8388 pub const TOTAL_SUPPLY_FIELD: &'static MessageField = &MessageField {
8389 name: "total_supply",
8390 json_name: "totalSupply",
8391 number: 2i32,
8392 message_fields: None,
8393 };
8394 pub const SUPPLY_STATE_FIELD: &'static MessageField = &MessageField {
8395 name: "supply_state",
8396 json_name: "supplyState",
8397 number: 3i32,
8398 message_fields: None,
8399 };
8400 }
8401 impl MessageFields for CoinTreasury {
8402 const FIELDS: &'static [&'static MessageField] = &[
8403 Self::ID_FIELD,
8404 Self::TOTAL_SUPPLY_FIELD,
8405 Self::SUPPLY_STATE_FIELD,
8406 ];
8407 }
8408 impl CoinTreasury {
8409 pub fn path_builder() -> CoinTreasuryFieldPathBuilder {
8410 CoinTreasuryFieldPathBuilder::new()
8411 }
8412 }
8413 pub struct CoinTreasuryFieldPathBuilder {
8414 path: Vec<&'static str>,
8415 }
8416 impl CoinTreasuryFieldPathBuilder {
8417 #[allow(clippy::new_without_default)]
8418 pub fn new() -> Self {
8419 Self { path: Default::default() }
8420 }
8421 #[doc(hidden)]
8422 pub fn new_with_base(base: Vec<&'static str>) -> Self {
8423 Self { path: base }
8424 }
8425 pub fn finish(self) -> String {
8426 self.path.join(".")
8427 }
8428 pub fn id(mut self) -> String {
8429 self.path.push(CoinTreasury::ID_FIELD.name);
8430 self.finish()
8431 }
8432 pub fn total_supply(mut self) -> String {
8433 self.path.push(CoinTreasury::TOTAL_SUPPLY_FIELD.name);
8434 self.finish()
8435 }
8436 pub fn supply_state(mut self) -> String {
8437 self.path.push(CoinTreasury::SUPPLY_STATE_FIELD.name);
8438 self.finish()
8439 }
8440 }
8441 impl RegulatedCoinMetadata {
8442 pub const ID_FIELD: &'static MessageField = &MessageField {
8443 name: "id",
8444 json_name: "id",
8445 number: 1i32,
8446 message_fields: None,
8447 };
8448 pub const COIN_METADATA_OBJECT_FIELD: &'static MessageField = &MessageField {
8449 name: "coin_metadata_object",
8450 json_name: "coinMetadataObject",
8451 number: 2i32,
8452 message_fields: None,
8453 };
8454 pub const DENY_CAP_OBJECT_FIELD: &'static MessageField = &MessageField {
8455 name: "deny_cap_object",
8456 json_name: "denyCapObject",
8457 number: 3i32,
8458 message_fields: None,
8459 };
8460 pub const ALLOW_GLOBAL_PAUSE_FIELD: &'static MessageField = &MessageField {
8461 name: "allow_global_pause",
8462 json_name: "allowGlobalPause",
8463 number: 4i32,
8464 message_fields: None,
8465 };
8466 pub const VARIANT_FIELD: &'static MessageField = &MessageField {
8467 name: "variant",
8468 json_name: "variant",
8469 number: 5i32,
8470 message_fields: None,
8471 };
8472 pub const COIN_REGULATED_STATE_FIELD: &'static MessageField = &MessageField {
8473 name: "coin_regulated_state",
8474 json_name: "coinRegulatedState",
8475 number: 6i32,
8476 message_fields: None,
8477 };
8478 }
8479 impl MessageFields for RegulatedCoinMetadata {
8480 const FIELDS: &'static [&'static MessageField] = &[
8481 Self::ID_FIELD,
8482 Self::COIN_METADATA_OBJECT_FIELD,
8483 Self::DENY_CAP_OBJECT_FIELD,
8484 Self::ALLOW_GLOBAL_PAUSE_FIELD,
8485 Self::VARIANT_FIELD,
8486 Self::COIN_REGULATED_STATE_FIELD,
8487 ];
8488 }
8489 impl RegulatedCoinMetadata {
8490 pub fn path_builder() -> RegulatedCoinMetadataFieldPathBuilder {
8491 RegulatedCoinMetadataFieldPathBuilder::new()
8492 }
8493 }
8494 pub struct RegulatedCoinMetadataFieldPathBuilder {
8495 path: Vec<&'static str>,
8496 }
8497 impl RegulatedCoinMetadataFieldPathBuilder {
8498 #[allow(clippy::new_without_default)]
8499 pub fn new() -> Self {
8500 Self { path: Default::default() }
8501 }
8502 #[doc(hidden)]
8503 pub fn new_with_base(base: Vec<&'static str>) -> Self {
8504 Self { path: base }
8505 }
8506 pub fn finish(self) -> String {
8507 self.path.join(".")
8508 }
8509 pub fn id(mut self) -> String {
8510 self.path.push(RegulatedCoinMetadata::ID_FIELD.name);
8511 self.finish()
8512 }
8513 pub fn coin_metadata_object(mut self) -> String {
8514 self.path.push(RegulatedCoinMetadata::COIN_METADATA_OBJECT_FIELD.name);
8515 self.finish()
8516 }
8517 pub fn deny_cap_object(mut self) -> String {
8518 self.path.push(RegulatedCoinMetadata::DENY_CAP_OBJECT_FIELD.name);
8519 self.finish()
8520 }
8521 pub fn allow_global_pause(mut self) -> String {
8522 self.path.push(RegulatedCoinMetadata::ALLOW_GLOBAL_PAUSE_FIELD.name);
8523 self.finish()
8524 }
8525 pub fn variant(mut self) -> String {
8526 self.path.push(RegulatedCoinMetadata::VARIANT_FIELD.name);
8527 self.finish()
8528 }
8529 pub fn coin_regulated_state(mut self) -> String {
8530 self.path.push(RegulatedCoinMetadata::COIN_REGULATED_STATE_FIELD.name);
8531 self.finish()
8532 }
8533 }
8534 impl GetBalanceRequest {
8535 pub const OWNER_FIELD: &'static MessageField = &MessageField {
8536 name: "owner",
8537 json_name: "owner",
8538 number: 1i32,
8539 message_fields: None,
8540 };
8541 pub const COIN_TYPE_FIELD: &'static MessageField = &MessageField {
8542 name: "coin_type",
8543 json_name: "coinType",
8544 number: 2i32,
8545 message_fields: None,
8546 };
8547 }
8548 impl MessageFields for GetBalanceRequest {
8549 const FIELDS: &'static [&'static MessageField] = &[
8550 Self::OWNER_FIELD,
8551 Self::COIN_TYPE_FIELD,
8552 ];
8553 }
8554 impl GetBalanceRequest {
8555 pub fn path_builder() -> GetBalanceRequestFieldPathBuilder {
8556 GetBalanceRequestFieldPathBuilder::new()
8557 }
8558 }
8559 pub struct GetBalanceRequestFieldPathBuilder {
8560 path: Vec<&'static str>,
8561 }
8562 impl GetBalanceRequestFieldPathBuilder {
8563 #[allow(clippy::new_without_default)]
8564 pub fn new() -> Self {
8565 Self { path: Default::default() }
8566 }
8567 #[doc(hidden)]
8568 pub fn new_with_base(base: Vec<&'static str>) -> Self {
8569 Self { path: base }
8570 }
8571 pub fn finish(self) -> String {
8572 self.path.join(".")
8573 }
8574 pub fn owner(mut self) -> String {
8575 self.path.push(GetBalanceRequest::OWNER_FIELD.name);
8576 self.finish()
8577 }
8578 pub fn coin_type(mut self) -> String {
8579 self.path.push(GetBalanceRequest::COIN_TYPE_FIELD.name);
8580 self.finish()
8581 }
8582 }
8583 impl GetBalanceResponse {
8584 pub const BALANCE_FIELD: &'static MessageField = &MessageField {
8585 name: "balance",
8586 json_name: "balance",
8587 number: 1i32,
8588 message_fields: Some(Balance::FIELDS),
8589 };
8590 }
8591 impl MessageFields for GetBalanceResponse {
8592 const FIELDS: &'static [&'static MessageField] = &[Self::BALANCE_FIELD];
8593 }
8594 impl GetBalanceResponse {
8595 pub fn path_builder() -> GetBalanceResponseFieldPathBuilder {
8596 GetBalanceResponseFieldPathBuilder::new()
8597 }
8598 }
8599 pub struct GetBalanceResponseFieldPathBuilder {
8600 path: Vec<&'static str>,
8601 }
8602 impl GetBalanceResponseFieldPathBuilder {
8603 #[allow(clippy::new_without_default)]
8604 pub fn new() -> Self {
8605 Self { path: Default::default() }
8606 }
8607 #[doc(hidden)]
8608 pub fn new_with_base(base: Vec<&'static str>) -> Self {
8609 Self { path: base }
8610 }
8611 pub fn finish(self) -> String {
8612 self.path.join(".")
8613 }
8614 pub fn balance(mut self) -> BalanceFieldPathBuilder {
8615 self.path.push(GetBalanceResponse::BALANCE_FIELD.name);
8616 BalanceFieldPathBuilder::new_with_base(self.path)
8617 }
8618 }
8619 impl ListBalancesRequest {
8620 pub const OWNER_FIELD: &'static MessageField = &MessageField {
8621 name: "owner",
8622 json_name: "owner",
8623 number: 1i32,
8624 message_fields: None,
8625 };
8626 pub const PAGE_SIZE_FIELD: &'static MessageField = &MessageField {
8627 name: "page_size",
8628 json_name: "pageSize",
8629 number: 2i32,
8630 message_fields: None,
8631 };
8632 pub const PAGE_TOKEN_FIELD: &'static MessageField = &MessageField {
8633 name: "page_token",
8634 json_name: "pageToken",
8635 number: 3i32,
8636 message_fields: None,
8637 };
8638 }
8639 impl MessageFields for ListBalancesRequest {
8640 const FIELDS: &'static [&'static MessageField] = &[
8641 Self::OWNER_FIELD,
8642 Self::PAGE_SIZE_FIELD,
8643 Self::PAGE_TOKEN_FIELD,
8644 ];
8645 }
8646 impl ListBalancesRequest {
8647 pub fn path_builder() -> ListBalancesRequestFieldPathBuilder {
8648 ListBalancesRequestFieldPathBuilder::new()
8649 }
8650 }
8651 pub struct ListBalancesRequestFieldPathBuilder {
8652 path: Vec<&'static str>,
8653 }
8654 impl ListBalancesRequestFieldPathBuilder {
8655 #[allow(clippy::new_without_default)]
8656 pub fn new() -> Self {
8657 Self { path: Default::default() }
8658 }
8659 #[doc(hidden)]
8660 pub fn new_with_base(base: Vec<&'static str>) -> Self {
8661 Self { path: base }
8662 }
8663 pub fn finish(self) -> String {
8664 self.path.join(".")
8665 }
8666 pub fn owner(mut self) -> String {
8667 self.path.push(ListBalancesRequest::OWNER_FIELD.name);
8668 self.finish()
8669 }
8670 pub fn page_size(mut self) -> String {
8671 self.path.push(ListBalancesRequest::PAGE_SIZE_FIELD.name);
8672 self.finish()
8673 }
8674 pub fn page_token(mut self) -> String {
8675 self.path.push(ListBalancesRequest::PAGE_TOKEN_FIELD.name);
8676 self.finish()
8677 }
8678 }
8679 impl ListBalancesResponse {
8680 pub const BALANCES_FIELD: &'static MessageField = &MessageField {
8681 name: "balances",
8682 json_name: "balances",
8683 number: 1i32,
8684 message_fields: Some(Balance::FIELDS),
8685 };
8686 pub const NEXT_PAGE_TOKEN_FIELD: &'static MessageField = &MessageField {
8687 name: "next_page_token",
8688 json_name: "nextPageToken",
8689 number: 2i32,
8690 message_fields: None,
8691 };
8692 }
8693 impl MessageFields for ListBalancesResponse {
8694 const FIELDS: &'static [&'static MessageField] = &[
8695 Self::BALANCES_FIELD,
8696 Self::NEXT_PAGE_TOKEN_FIELD,
8697 ];
8698 }
8699 impl ListBalancesResponse {
8700 pub fn path_builder() -> ListBalancesResponseFieldPathBuilder {
8701 ListBalancesResponseFieldPathBuilder::new()
8702 }
8703 }
8704 pub struct ListBalancesResponseFieldPathBuilder {
8705 path: Vec<&'static str>,
8706 }
8707 impl ListBalancesResponseFieldPathBuilder {
8708 #[allow(clippy::new_without_default)]
8709 pub fn new() -> Self {
8710 Self { path: Default::default() }
8711 }
8712 #[doc(hidden)]
8713 pub fn new_with_base(base: Vec<&'static str>) -> Self {
8714 Self { path: base }
8715 }
8716 pub fn finish(self) -> String {
8717 self.path.join(".")
8718 }
8719 pub fn balances(mut self) -> BalanceFieldPathBuilder {
8720 self.path.push(ListBalancesResponse::BALANCES_FIELD.name);
8721 BalanceFieldPathBuilder::new_with_base(self.path)
8722 }
8723 pub fn next_page_token(mut self) -> String {
8724 self.path.push(ListBalancesResponse::NEXT_PAGE_TOKEN_FIELD.name);
8725 self.finish()
8726 }
8727 }
8728 impl Balance {
8729 pub const COIN_TYPE_FIELD: &'static MessageField = &MessageField {
8730 name: "coin_type",
8731 json_name: "coinType",
8732 number: 1i32,
8733 message_fields: None,
8734 };
8735 pub const BALANCE_FIELD: &'static MessageField = &MessageField {
8736 name: "balance",
8737 json_name: "balance",
8738 number: 3i32,
8739 message_fields: None,
8740 };
8741 pub const ADDRESS_BALANCE_FIELD: &'static MessageField = &MessageField {
8742 name: "address_balance",
8743 json_name: "addressBalance",
8744 number: 4i32,
8745 message_fields: None,
8746 };
8747 pub const COIN_BALANCE_FIELD: &'static MessageField = &MessageField {
8748 name: "coin_balance",
8749 json_name: "coinBalance",
8750 number: 5i32,
8751 message_fields: None,
8752 };
8753 }
8754 impl MessageFields for Balance {
8755 const FIELDS: &'static [&'static MessageField] = &[
8756 Self::COIN_TYPE_FIELD,
8757 Self::BALANCE_FIELD,
8758 Self::ADDRESS_BALANCE_FIELD,
8759 Self::COIN_BALANCE_FIELD,
8760 ];
8761 }
8762 impl Balance {
8763 pub fn path_builder() -> BalanceFieldPathBuilder {
8764 BalanceFieldPathBuilder::new()
8765 }
8766 }
8767 pub struct BalanceFieldPathBuilder {
8768 path: Vec<&'static str>,
8769 }
8770 impl BalanceFieldPathBuilder {
8771 #[allow(clippy::new_without_default)]
8772 pub fn new() -> Self {
8773 Self { path: Default::default() }
8774 }
8775 #[doc(hidden)]
8776 pub fn new_with_base(base: Vec<&'static str>) -> Self {
8777 Self { path: base }
8778 }
8779 pub fn finish(self) -> String {
8780 self.path.join(".")
8781 }
8782 pub fn coin_type(mut self) -> String {
8783 self.path.push(Balance::COIN_TYPE_FIELD.name);
8784 self.finish()
8785 }
8786 pub fn balance(mut self) -> String {
8787 self.path.push(Balance::BALANCE_FIELD.name);
8788 self.finish()
8789 }
8790 pub fn address_balance(mut self) -> String {
8791 self.path.push(Balance::ADDRESS_BALANCE_FIELD.name);
8792 self.finish()
8793 }
8794 pub fn coin_balance(mut self) -> String {
8795 self.path.push(Balance::COIN_BALANCE_FIELD.name);
8796 self.finish()
8797 }
8798 }
8799 impl ListDynamicFieldsRequest {
8800 pub const PARENT_FIELD: &'static MessageField = &MessageField {
8801 name: "parent",
8802 json_name: "parent",
8803 number: 1i32,
8804 message_fields: None,
8805 };
8806 pub const PAGE_SIZE_FIELD: &'static MessageField = &MessageField {
8807 name: "page_size",
8808 json_name: "pageSize",
8809 number: 2i32,
8810 message_fields: None,
8811 };
8812 pub const PAGE_TOKEN_FIELD: &'static MessageField = &MessageField {
8813 name: "page_token",
8814 json_name: "pageToken",
8815 number: 3i32,
8816 message_fields: None,
8817 };
8818 pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
8819 name: "read_mask",
8820 json_name: "readMask",
8821 number: 4i32,
8822 message_fields: None,
8823 };
8824 }
8825 impl MessageFields for ListDynamicFieldsRequest {
8826 const FIELDS: &'static [&'static MessageField] = &[
8827 Self::PARENT_FIELD,
8828 Self::PAGE_SIZE_FIELD,
8829 Self::PAGE_TOKEN_FIELD,
8830 Self::READ_MASK_FIELD,
8831 ];
8832 }
8833 impl ListDynamicFieldsRequest {
8834 pub fn path_builder() -> ListDynamicFieldsRequestFieldPathBuilder {
8835 ListDynamicFieldsRequestFieldPathBuilder::new()
8836 }
8837 }
8838 pub struct ListDynamicFieldsRequestFieldPathBuilder {
8839 path: Vec<&'static str>,
8840 }
8841 impl ListDynamicFieldsRequestFieldPathBuilder {
8842 #[allow(clippy::new_without_default)]
8843 pub fn new() -> Self {
8844 Self { path: Default::default() }
8845 }
8846 #[doc(hidden)]
8847 pub fn new_with_base(base: Vec<&'static str>) -> Self {
8848 Self { path: base }
8849 }
8850 pub fn finish(self) -> String {
8851 self.path.join(".")
8852 }
8853 pub fn parent(mut self) -> String {
8854 self.path.push(ListDynamicFieldsRequest::PARENT_FIELD.name);
8855 self.finish()
8856 }
8857 pub fn page_size(mut self) -> String {
8858 self.path.push(ListDynamicFieldsRequest::PAGE_SIZE_FIELD.name);
8859 self.finish()
8860 }
8861 pub fn page_token(mut self) -> String {
8862 self.path.push(ListDynamicFieldsRequest::PAGE_TOKEN_FIELD.name);
8863 self.finish()
8864 }
8865 pub fn read_mask(mut self) -> String {
8866 self.path.push(ListDynamicFieldsRequest::READ_MASK_FIELD.name);
8867 self.finish()
8868 }
8869 }
8870 impl ListDynamicFieldsResponse {
8871 pub const DYNAMIC_FIELDS_FIELD: &'static MessageField = &MessageField {
8872 name: "dynamic_fields",
8873 json_name: "dynamicFields",
8874 number: 1i32,
8875 message_fields: Some(DynamicField::FIELDS),
8876 };
8877 pub const NEXT_PAGE_TOKEN_FIELD: &'static MessageField = &MessageField {
8878 name: "next_page_token",
8879 json_name: "nextPageToken",
8880 number: 2i32,
8881 message_fields: None,
8882 };
8883 }
8884 impl MessageFields for ListDynamicFieldsResponse {
8885 const FIELDS: &'static [&'static MessageField] = &[
8886 Self::DYNAMIC_FIELDS_FIELD,
8887 Self::NEXT_PAGE_TOKEN_FIELD,
8888 ];
8889 }
8890 impl ListDynamicFieldsResponse {
8891 pub fn path_builder() -> ListDynamicFieldsResponseFieldPathBuilder {
8892 ListDynamicFieldsResponseFieldPathBuilder::new()
8893 }
8894 }
8895 pub struct ListDynamicFieldsResponseFieldPathBuilder {
8896 path: Vec<&'static str>,
8897 }
8898 impl ListDynamicFieldsResponseFieldPathBuilder {
8899 #[allow(clippy::new_without_default)]
8900 pub fn new() -> Self {
8901 Self { path: Default::default() }
8902 }
8903 #[doc(hidden)]
8904 pub fn new_with_base(base: Vec<&'static str>) -> Self {
8905 Self { path: base }
8906 }
8907 pub fn finish(self) -> String {
8908 self.path.join(".")
8909 }
8910 pub fn dynamic_fields(mut self) -> DynamicFieldFieldPathBuilder {
8911 self.path.push(ListDynamicFieldsResponse::DYNAMIC_FIELDS_FIELD.name);
8912 DynamicFieldFieldPathBuilder::new_with_base(self.path)
8913 }
8914 pub fn next_page_token(mut self) -> String {
8915 self.path.push(ListDynamicFieldsResponse::NEXT_PAGE_TOKEN_FIELD.name);
8916 self.finish()
8917 }
8918 }
8919 impl DynamicField {
8920 pub const KIND_FIELD: &'static MessageField = &MessageField {
8921 name: "kind",
8922 json_name: "kind",
8923 number: 1i32,
8924 message_fields: None,
8925 };
8926 pub const PARENT_FIELD: &'static MessageField = &MessageField {
8927 name: "parent",
8928 json_name: "parent",
8929 number: 2i32,
8930 message_fields: None,
8931 };
8932 pub const FIELD_ID_FIELD: &'static MessageField = &MessageField {
8933 name: "field_id",
8934 json_name: "fieldId",
8935 number: 3i32,
8936 message_fields: None,
8937 };
8938 pub const FIELD_OBJECT_FIELD: &'static MessageField = &MessageField {
8939 name: "field_object",
8940 json_name: "fieldObject",
8941 number: 4i32,
8942 message_fields: Some(Object::FIELDS),
8943 };
8944 pub const NAME_FIELD: &'static MessageField = &MessageField {
8945 name: "name",
8946 json_name: "name",
8947 number: 5i32,
8948 message_fields: Some(Bcs::FIELDS),
8949 };
8950 pub const VALUE_FIELD: &'static MessageField = &MessageField {
8951 name: "value",
8952 json_name: "value",
8953 number: 6i32,
8954 message_fields: Some(Bcs::FIELDS),
8955 };
8956 pub const VALUE_TYPE_FIELD: &'static MessageField = &MessageField {
8957 name: "value_type",
8958 json_name: "valueType",
8959 number: 7i32,
8960 message_fields: None,
8961 };
8962 pub const CHILD_ID_FIELD: &'static MessageField = &MessageField {
8963 name: "child_id",
8964 json_name: "childId",
8965 number: 8i32,
8966 message_fields: None,
8967 };
8968 pub const CHILD_OBJECT_FIELD: &'static MessageField = &MessageField {
8969 name: "child_object",
8970 json_name: "childObject",
8971 number: 9i32,
8972 message_fields: Some(Object::FIELDS),
8973 };
8974 }
8975 impl MessageFields for DynamicField {
8976 const FIELDS: &'static [&'static MessageField] = &[
8977 Self::KIND_FIELD,
8978 Self::PARENT_FIELD,
8979 Self::FIELD_ID_FIELD,
8980 Self::FIELD_OBJECT_FIELD,
8981 Self::NAME_FIELD,
8982 Self::VALUE_FIELD,
8983 Self::VALUE_TYPE_FIELD,
8984 Self::CHILD_ID_FIELD,
8985 Self::CHILD_OBJECT_FIELD,
8986 ];
8987 }
8988 impl DynamicField {
8989 pub fn path_builder() -> DynamicFieldFieldPathBuilder {
8990 DynamicFieldFieldPathBuilder::new()
8991 }
8992 }
8993 pub struct DynamicFieldFieldPathBuilder {
8994 path: Vec<&'static str>,
8995 }
8996 impl DynamicFieldFieldPathBuilder {
8997 #[allow(clippy::new_without_default)]
8998 pub fn new() -> Self {
8999 Self { path: Default::default() }
9000 }
9001 #[doc(hidden)]
9002 pub fn new_with_base(base: Vec<&'static str>) -> Self {
9003 Self { path: base }
9004 }
9005 pub fn finish(self) -> String {
9006 self.path.join(".")
9007 }
9008 pub fn kind(mut self) -> String {
9009 self.path.push(DynamicField::KIND_FIELD.name);
9010 self.finish()
9011 }
9012 pub fn parent(mut self) -> String {
9013 self.path.push(DynamicField::PARENT_FIELD.name);
9014 self.finish()
9015 }
9016 pub fn field_id(mut self) -> String {
9017 self.path.push(DynamicField::FIELD_ID_FIELD.name);
9018 self.finish()
9019 }
9020 pub fn field_object(mut self) -> ObjectFieldPathBuilder {
9021 self.path.push(DynamicField::FIELD_OBJECT_FIELD.name);
9022 ObjectFieldPathBuilder::new_with_base(self.path)
9023 }
9024 pub fn name(mut self) -> BcsFieldPathBuilder {
9025 self.path.push(DynamicField::NAME_FIELD.name);
9026 BcsFieldPathBuilder::new_with_base(self.path)
9027 }
9028 pub fn value(mut self) -> BcsFieldPathBuilder {
9029 self.path.push(DynamicField::VALUE_FIELD.name);
9030 BcsFieldPathBuilder::new_with_base(self.path)
9031 }
9032 pub fn value_type(mut self) -> String {
9033 self.path.push(DynamicField::VALUE_TYPE_FIELD.name);
9034 self.finish()
9035 }
9036 pub fn child_id(mut self) -> String {
9037 self.path.push(DynamicField::CHILD_ID_FIELD.name);
9038 self.finish()
9039 }
9040 pub fn child_object(mut self) -> ObjectFieldPathBuilder {
9041 self.path.push(DynamicField::CHILD_OBJECT_FIELD.name);
9042 ObjectFieldPathBuilder::new_with_base(self.path)
9043 }
9044 }
9045 impl ListOwnedObjectsRequest {
9046 pub const OWNER_FIELD: &'static MessageField = &MessageField {
9047 name: "owner",
9048 json_name: "owner",
9049 number: 1i32,
9050 message_fields: None,
9051 };
9052 pub const PAGE_SIZE_FIELD: &'static MessageField = &MessageField {
9053 name: "page_size",
9054 json_name: "pageSize",
9055 number: 2i32,
9056 message_fields: None,
9057 };
9058 pub const PAGE_TOKEN_FIELD: &'static MessageField = &MessageField {
9059 name: "page_token",
9060 json_name: "pageToken",
9061 number: 3i32,
9062 message_fields: None,
9063 };
9064 pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
9065 name: "read_mask",
9066 json_name: "readMask",
9067 number: 4i32,
9068 message_fields: None,
9069 };
9070 pub const OBJECT_TYPE_FIELD: &'static MessageField = &MessageField {
9071 name: "object_type",
9072 json_name: "objectType",
9073 number: 5i32,
9074 message_fields: None,
9075 };
9076 }
9077 impl MessageFields for ListOwnedObjectsRequest {
9078 const FIELDS: &'static [&'static MessageField] = &[
9079 Self::OWNER_FIELD,
9080 Self::PAGE_SIZE_FIELD,
9081 Self::PAGE_TOKEN_FIELD,
9082 Self::READ_MASK_FIELD,
9083 Self::OBJECT_TYPE_FIELD,
9084 ];
9085 }
9086 impl ListOwnedObjectsRequest {
9087 pub fn path_builder() -> ListOwnedObjectsRequestFieldPathBuilder {
9088 ListOwnedObjectsRequestFieldPathBuilder::new()
9089 }
9090 }
9091 pub struct ListOwnedObjectsRequestFieldPathBuilder {
9092 path: Vec<&'static str>,
9093 }
9094 impl ListOwnedObjectsRequestFieldPathBuilder {
9095 #[allow(clippy::new_without_default)]
9096 pub fn new() -> Self {
9097 Self { path: Default::default() }
9098 }
9099 #[doc(hidden)]
9100 pub fn new_with_base(base: Vec<&'static str>) -> Self {
9101 Self { path: base }
9102 }
9103 pub fn finish(self) -> String {
9104 self.path.join(".")
9105 }
9106 pub fn owner(mut self) -> String {
9107 self.path.push(ListOwnedObjectsRequest::OWNER_FIELD.name);
9108 self.finish()
9109 }
9110 pub fn page_size(mut self) -> String {
9111 self.path.push(ListOwnedObjectsRequest::PAGE_SIZE_FIELD.name);
9112 self.finish()
9113 }
9114 pub fn page_token(mut self) -> String {
9115 self.path.push(ListOwnedObjectsRequest::PAGE_TOKEN_FIELD.name);
9116 self.finish()
9117 }
9118 pub fn read_mask(mut self) -> String {
9119 self.path.push(ListOwnedObjectsRequest::READ_MASK_FIELD.name);
9120 self.finish()
9121 }
9122 pub fn object_type(mut self) -> String {
9123 self.path.push(ListOwnedObjectsRequest::OBJECT_TYPE_FIELD.name);
9124 self.finish()
9125 }
9126 }
9127 impl ListOwnedObjectsResponse {
9128 pub const OBJECTS_FIELD: &'static MessageField = &MessageField {
9129 name: "objects",
9130 json_name: "objects",
9131 number: 1i32,
9132 message_fields: Some(Object::FIELDS),
9133 };
9134 pub const NEXT_PAGE_TOKEN_FIELD: &'static MessageField = &MessageField {
9135 name: "next_page_token",
9136 json_name: "nextPageToken",
9137 number: 2i32,
9138 message_fields: None,
9139 };
9140 }
9141 impl MessageFields for ListOwnedObjectsResponse {
9142 const FIELDS: &'static [&'static MessageField] = &[
9143 Self::OBJECTS_FIELD,
9144 Self::NEXT_PAGE_TOKEN_FIELD,
9145 ];
9146 }
9147 impl ListOwnedObjectsResponse {
9148 pub fn path_builder() -> ListOwnedObjectsResponseFieldPathBuilder {
9149 ListOwnedObjectsResponseFieldPathBuilder::new()
9150 }
9151 }
9152 pub struct ListOwnedObjectsResponseFieldPathBuilder {
9153 path: Vec<&'static str>,
9154 }
9155 impl ListOwnedObjectsResponseFieldPathBuilder {
9156 #[allow(clippy::new_without_default)]
9157 pub fn new() -> Self {
9158 Self { path: Default::default() }
9159 }
9160 #[doc(hidden)]
9161 pub fn new_with_base(base: Vec<&'static str>) -> Self {
9162 Self { path: base }
9163 }
9164 pub fn finish(self) -> String {
9165 self.path.join(".")
9166 }
9167 pub fn objects(mut self) -> ObjectFieldPathBuilder {
9168 self.path.push(ListOwnedObjectsResponse::OBJECTS_FIELD.name);
9169 ObjectFieldPathBuilder::new_with_base(self.path)
9170 }
9171 pub fn next_page_token(mut self) -> String {
9172 self.path.push(ListOwnedObjectsResponse::NEXT_PAGE_TOKEN_FIELD.name);
9173 self.finish()
9174 }
9175 }
9176 impl SubscribeCheckpointsRequest {
9177 pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
9178 name: "read_mask",
9179 json_name: "readMask",
9180 number: 1i32,
9181 message_fields: None,
9182 };
9183 pub const FILTER_FIELD: &'static MessageField = &MessageField {
9184 name: "filter",
9185 json_name: "filter",
9186 number: 2i32,
9187 message_fields: Some(TransactionFilter::FIELDS),
9188 };
9189 }
9190 impl MessageFields for SubscribeCheckpointsRequest {
9191 const FIELDS: &'static [&'static MessageField] = &[
9192 Self::READ_MASK_FIELD,
9193 Self::FILTER_FIELD,
9194 ];
9195 }
9196 impl SubscribeCheckpointsRequest {
9197 pub fn path_builder() -> SubscribeCheckpointsRequestFieldPathBuilder {
9198 SubscribeCheckpointsRequestFieldPathBuilder::new()
9199 }
9200 }
9201 pub struct SubscribeCheckpointsRequestFieldPathBuilder {
9202 path: Vec<&'static str>,
9203 }
9204 impl SubscribeCheckpointsRequestFieldPathBuilder {
9205 #[allow(clippy::new_without_default)]
9206 pub fn new() -> Self {
9207 Self { path: Default::default() }
9208 }
9209 #[doc(hidden)]
9210 pub fn new_with_base(base: Vec<&'static str>) -> Self {
9211 Self { path: base }
9212 }
9213 pub fn finish(self) -> String {
9214 self.path.join(".")
9215 }
9216 pub fn read_mask(mut self) -> String {
9217 self.path.push(SubscribeCheckpointsRequest::READ_MASK_FIELD.name);
9218 self.finish()
9219 }
9220 pub fn filter(mut self) -> TransactionFilterFieldPathBuilder {
9221 self.path.push(SubscribeCheckpointsRequest::FILTER_FIELD.name);
9222 TransactionFilterFieldPathBuilder::new_with_base(self.path)
9223 }
9224 }
9225 impl SubscribeCheckpointsResponse {
9226 pub const CURSOR_FIELD: &'static MessageField = &MessageField {
9227 name: "cursor",
9228 json_name: "cursor",
9229 number: 1i32,
9230 message_fields: None,
9231 };
9232 pub const CHECKPOINT_FIELD: &'static MessageField = &MessageField {
9233 name: "checkpoint",
9234 json_name: "checkpoint",
9235 number: 2i32,
9236 message_fields: Some(Checkpoint::FIELDS),
9237 };
9238 }
9239 impl MessageFields for SubscribeCheckpointsResponse {
9240 const FIELDS: &'static [&'static MessageField] = &[
9241 Self::CURSOR_FIELD,
9242 Self::CHECKPOINT_FIELD,
9243 ];
9244 }
9245 impl SubscribeCheckpointsResponse {
9246 pub fn path_builder() -> SubscribeCheckpointsResponseFieldPathBuilder {
9247 SubscribeCheckpointsResponseFieldPathBuilder::new()
9248 }
9249 }
9250 pub struct SubscribeCheckpointsResponseFieldPathBuilder {
9251 path: Vec<&'static str>,
9252 }
9253 impl SubscribeCheckpointsResponseFieldPathBuilder {
9254 #[allow(clippy::new_without_default)]
9255 pub fn new() -> Self {
9256 Self { path: Default::default() }
9257 }
9258 #[doc(hidden)]
9259 pub fn new_with_base(base: Vec<&'static str>) -> Self {
9260 Self { path: base }
9261 }
9262 pub fn finish(self) -> String {
9263 self.path.join(".")
9264 }
9265 pub fn cursor(mut self) -> String {
9266 self.path.push(SubscribeCheckpointsResponse::CURSOR_FIELD.name);
9267 self.finish()
9268 }
9269 pub fn checkpoint(mut self) -> CheckpointFieldPathBuilder {
9270 self.path.push(SubscribeCheckpointsResponse::CHECKPOINT_FIELD.name);
9271 CheckpointFieldPathBuilder::new_with_base(self.path)
9272 }
9273 }
9274 impl SubscribeTransactionsRequest {
9275 pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
9276 name: "read_mask",
9277 json_name: "readMask",
9278 number: 1i32,
9279 message_fields: None,
9280 };
9281 pub const FILTER_FIELD: &'static MessageField = &MessageField {
9282 name: "filter",
9283 json_name: "filter",
9284 number: 2i32,
9285 message_fields: Some(TransactionFilter::FIELDS),
9286 };
9287 }
9288 impl MessageFields for SubscribeTransactionsRequest {
9289 const FIELDS: &'static [&'static MessageField] = &[
9290 Self::READ_MASK_FIELD,
9291 Self::FILTER_FIELD,
9292 ];
9293 }
9294 impl SubscribeTransactionsRequest {
9295 pub fn path_builder() -> SubscribeTransactionsRequestFieldPathBuilder {
9296 SubscribeTransactionsRequestFieldPathBuilder::new()
9297 }
9298 }
9299 pub struct SubscribeTransactionsRequestFieldPathBuilder {
9300 path: Vec<&'static str>,
9301 }
9302 impl SubscribeTransactionsRequestFieldPathBuilder {
9303 #[allow(clippy::new_without_default)]
9304 pub fn new() -> Self {
9305 Self { path: Default::default() }
9306 }
9307 #[doc(hidden)]
9308 pub fn new_with_base(base: Vec<&'static str>) -> Self {
9309 Self { path: base }
9310 }
9311 pub fn finish(self) -> String {
9312 self.path.join(".")
9313 }
9314 pub fn read_mask(mut self) -> String {
9315 self.path.push(SubscribeTransactionsRequest::READ_MASK_FIELD.name);
9316 self.finish()
9317 }
9318 pub fn filter(mut self) -> TransactionFilterFieldPathBuilder {
9319 self.path.push(SubscribeTransactionsRequest::FILTER_FIELD.name);
9320 TransactionFilterFieldPathBuilder::new_with_base(self.path)
9321 }
9322 }
9323 impl SubscribeTransactionsResponse {
9324 pub const TRANSACTION_FIELD: &'static MessageField = &MessageField {
9325 name: "transaction",
9326 json_name: "transaction",
9327 number: 1i32,
9328 message_fields: Some(ExecutedTransaction::FIELDS),
9329 };
9330 pub const WATERMARK_FIELD: &'static MessageField = &MessageField {
9331 name: "watermark",
9332 json_name: "watermark",
9333 number: 2i32,
9334 message_fields: Some(Watermark::FIELDS),
9335 };
9336 }
9337 impl MessageFields for SubscribeTransactionsResponse {
9338 const FIELDS: &'static [&'static MessageField] = &[
9339 Self::TRANSACTION_FIELD,
9340 Self::WATERMARK_FIELD,
9341 ];
9342 }
9343 impl SubscribeTransactionsResponse {
9344 pub fn path_builder() -> SubscribeTransactionsResponseFieldPathBuilder {
9345 SubscribeTransactionsResponseFieldPathBuilder::new()
9346 }
9347 }
9348 pub struct SubscribeTransactionsResponseFieldPathBuilder {
9349 path: Vec<&'static str>,
9350 }
9351 impl SubscribeTransactionsResponseFieldPathBuilder {
9352 #[allow(clippy::new_without_default)]
9353 pub fn new() -> Self {
9354 Self { path: Default::default() }
9355 }
9356 #[doc(hidden)]
9357 pub fn new_with_base(base: Vec<&'static str>) -> Self {
9358 Self { path: base }
9359 }
9360 pub fn finish(self) -> String {
9361 self.path.join(".")
9362 }
9363 pub fn transaction(mut self) -> ExecutedTransactionFieldPathBuilder {
9364 self.path.push(SubscribeTransactionsResponse::TRANSACTION_FIELD.name);
9365 ExecutedTransactionFieldPathBuilder::new_with_base(self.path)
9366 }
9367 pub fn watermark(mut self) -> WatermarkFieldPathBuilder {
9368 self.path.push(SubscribeTransactionsResponse::WATERMARK_FIELD.name);
9369 WatermarkFieldPathBuilder::new_with_base(self.path)
9370 }
9371 }
9372 impl SubscribeEventsRequest {
9373 pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
9374 name: "read_mask",
9375 json_name: "readMask",
9376 number: 1i32,
9377 message_fields: None,
9378 };
9379 pub const FILTER_FIELD: &'static MessageField = &MessageField {
9380 name: "filter",
9381 json_name: "filter",
9382 number: 2i32,
9383 message_fields: Some(EventFilter::FIELDS),
9384 };
9385 }
9386 impl MessageFields for SubscribeEventsRequest {
9387 const FIELDS: &'static [&'static MessageField] = &[
9388 Self::READ_MASK_FIELD,
9389 Self::FILTER_FIELD,
9390 ];
9391 }
9392 impl SubscribeEventsRequest {
9393 pub fn path_builder() -> SubscribeEventsRequestFieldPathBuilder {
9394 SubscribeEventsRequestFieldPathBuilder::new()
9395 }
9396 }
9397 pub struct SubscribeEventsRequestFieldPathBuilder {
9398 path: Vec<&'static str>,
9399 }
9400 impl SubscribeEventsRequestFieldPathBuilder {
9401 #[allow(clippy::new_without_default)]
9402 pub fn new() -> Self {
9403 Self { path: Default::default() }
9404 }
9405 #[doc(hidden)]
9406 pub fn new_with_base(base: Vec<&'static str>) -> Self {
9407 Self { path: base }
9408 }
9409 pub fn finish(self) -> String {
9410 self.path.join(".")
9411 }
9412 pub fn read_mask(mut self) -> String {
9413 self.path.push(SubscribeEventsRequest::READ_MASK_FIELD.name);
9414 self.finish()
9415 }
9416 pub fn filter(mut self) -> EventFilterFieldPathBuilder {
9417 self.path.push(SubscribeEventsRequest::FILTER_FIELD.name);
9418 EventFilterFieldPathBuilder::new_with_base(self.path)
9419 }
9420 }
9421 impl SubscribeEventsResponse {
9422 pub const EVENT_FIELD: &'static MessageField = &MessageField {
9423 name: "event",
9424 json_name: "event",
9425 number: 1i32,
9426 message_fields: Some(Event::FIELDS),
9427 };
9428 pub const WATERMARK_FIELD: &'static MessageField = &MessageField {
9429 name: "watermark",
9430 json_name: "watermark",
9431 number: 2i32,
9432 message_fields: Some(Watermark::FIELDS),
9433 };
9434 }
9435 impl MessageFields for SubscribeEventsResponse {
9436 const FIELDS: &'static [&'static MessageField] = &[
9437 Self::EVENT_FIELD,
9438 Self::WATERMARK_FIELD,
9439 ];
9440 }
9441 impl SubscribeEventsResponse {
9442 pub fn path_builder() -> SubscribeEventsResponseFieldPathBuilder {
9443 SubscribeEventsResponseFieldPathBuilder::new()
9444 }
9445 }
9446 pub struct SubscribeEventsResponseFieldPathBuilder {
9447 path: Vec<&'static str>,
9448 }
9449 impl SubscribeEventsResponseFieldPathBuilder {
9450 #[allow(clippy::new_without_default)]
9451 pub fn new() -> Self {
9452 Self { path: Default::default() }
9453 }
9454 #[doc(hidden)]
9455 pub fn new_with_base(base: Vec<&'static str>) -> Self {
9456 Self { path: base }
9457 }
9458 pub fn finish(self) -> String {
9459 self.path.join(".")
9460 }
9461 pub fn event(mut self) -> EventFieldPathBuilder {
9462 self.path.push(SubscribeEventsResponse::EVENT_FIELD.name);
9463 EventFieldPathBuilder::new_with_base(self.path)
9464 }
9465 pub fn watermark(mut self) -> WatermarkFieldPathBuilder {
9466 self.path.push(SubscribeEventsResponse::WATERMARK_FIELD.name);
9467 WatermarkFieldPathBuilder::new_with_base(self.path)
9468 }
9469 }
9470 impl SystemState {
9471 pub const VERSION_FIELD: &'static MessageField = &MessageField {
9472 name: "version",
9473 json_name: "version",
9474 number: 1i32,
9475 message_fields: None,
9476 };
9477 pub const EPOCH_FIELD: &'static MessageField = &MessageField {
9478 name: "epoch",
9479 json_name: "epoch",
9480 number: 2i32,
9481 message_fields: None,
9482 };
9483 pub const PROTOCOL_VERSION_FIELD: &'static MessageField = &MessageField {
9484 name: "protocol_version",
9485 json_name: "protocolVersion",
9486 number: 3i32,
9487 message_fields: None,
9488 };
9489 pub const VALIDATORS_FIELD: &'static MessageField = &MessageField {
9490 name: "validators",
9491 json_name: "validators",
9492 number: 4i32,
9493 message_fields: Some(ValidatorSet::FIELDS),
9494 };
9495 pub const STORAGE_FUND_FIELD: &'static MessageField = &MessageField {
9496 name: "storage_fund",
9497 json_name: "storageFund",
9498 number: 5i32,
9499 message_fields: Some(StorageFund::FIELDS),
9500 };
9501 pub const PARAMETERS_FIELD: &'static MessageField = &MessageField {
9502 name: "parameters",
9503 json_name: "parameters",
9504 number: 6i32,
9505 message_fields: Some(SystemParameters::FIELDS),
9506 };
9507 pub const REFERENCE_GAS_PRICE_FIELD: &'static MessageField = &MessageField {
9508 name: "reference_gas_price",
9509 json_name: "referenceGasPrice",
9510 number: 7i32,
9511 message_fields: None,
9512 };
9513 pub const VALIDATOR_REPORT_RECORDS_FIELD: &'static MessageField = &MessageField {
9514 name: "validator_report_records",
9515 json_name: "validatorReportRecords",
9516 number: 8i32,
9517 message_fields: Some(ValidatorReportRecord::FIELDS),
9518 };
9519 pub const STAKE_SUBSIDY_FIELD: &'static MessageField = &MessageField {
9520 name: "stake_subsidy",
9521 json_name: "stakeSubsidy",
9522 number: 9i32,
9523 message_fields: Some(StakeSubsidy::FIELDS),
9524 };
9525 pub const SAFE_MODE_FIELD: &'static MessageField = &MessageField {
9526 name: "safe_mode",
9527 json_name: "safeMode",
9528 number: 10i32,
9529 message_fields: None,
9530 };
9531 pub const SAFE_MODE_STORAGE_REWARDS_FIELD: &'static MessageField = &MessageField {
9532 name: "safe_mode_storage_rewards",
9533 json_name: "safeModeStorageRewards",
9534 number: 11i32,
9535 message_fields: None,
9536 };
9537 pub const SAFE_MODE_COMPUTATION_REWARDS_FIELD: &'static MessageField = &MessageField {
9538 name: "safe_mode_computation_rewards",
9539 json_name: "safeModeComputationRewards",
9540 number: 12i32,
9541 message_fields: None,
9542 };
9543 pub const SAFE_MODE_STORAGE_REBATES_FIELD: &'static MessageField = &MessageField {
9544 name: "safe_mode_storage_rebates",
9545 json_name: "safeModeStorageRebates",
9546 number: 13i32,
9547 message_fields: None,
9548 };
9549 pub const SAFE_MODE_NON_REFUNDABLE_STORAGE_FEE_FIELD: &'static MessageField = &MessageField {
9550 name: "safe_mode_non_refundable_storage_fee",
9551 json_name: "safeModeNonRefundableStorageFee",
9552 number: 14i32,
9553 message_fields: None,
9554 };
9555 pub const EPOCH_START_TIMESTAMP_MS_FIELD: &'static MessageField = &MessageField {
9556 name: "epoch_start_timestamp_ms",
9557 json_name: "epochStartTimestampMs",
9558 number: 15i32,
9559 message_fields: None,
9560 };
9561 pub const EXTRA_FIELDS_FIELD: &'static MessageField = &MessageField {
9562 name: "extra_fields",
9563 json_name: "extraFields",
9564 number: 16i32,
9565 message_fields: Some(MoveTable::FIELDS),
9566 };
9567 }
9568 impl MessageFields for SystemState {
9569 const FIELDS: &'static [&'static MessageField] = &[
9570 Self::VERSION_FIELD,
9571 Self::EPOCH_FIELD,
9572 Self::PROTOCOL_VERSION_FIELD,
9573 Self::VALIDATORS_FIELD,
9574 Self::STORAGE_FUND_FIELD,
9575 Self::PARAMETERS_FIELD,
9576 Self::REFERENCE_GAS_PRICE_FIELD,
9577 Self::VALIDATOR_REPORT_RECORDS_FIELD,
9578 Self::STAKE_SUBSIDY_FIELD,
9579 Self::SAFE_MODE_FIELD,
9580 Self::SAFE_MODE_STORAGE_REWARDS_FIELD,
9581 Self::SAFE_MODE_COMPUTATION_REWARDS_FIELD,
9582 Self::SAFE_MODE_STORAGE_REBATES_FIELD,
9583 Self::SAFE_MODE_NON_REFUNDABLE_STORAGE_FEE_FIELD,
9584 Self::EPOCH_START_TIMESTAMP_MS_FIELD,
9585 Self::EXTRA_FIELDS_FIELD,
9586 ];
9587 }
9588 impl SystemState {
9589 pub fn path_builder() -> SystemStateFieldPathBuilder {
9590 SystemStateFieldPathBuilder::new()
9591 }
9592 }
9593 pub struct SystemStateFieldPathBuilder {
9594 path: Vec<&'static str>,
9595 }
9596 impl SystemStateFieldPathBuilder {
9597 #[allow(clippy::new_without_default)]
9598 pub fn new() -> Self {
9599 Self { path: Default::default() }
9600 }
9601 #[doc(hidden)]
9602 pub fn new_with_base(base: Vec<&'static str>) -> Self {
9603 Self { path: base }
9604 }
9605 pub fn finish(self) -> String {
9606 self.path.join(".")
9607 }
9608 pub fn version(mut self) -> String {
9609 self.path.push(SystemState::VERSION_FIELD.name);
9610 self.finish()
9611 }
9612 pub fn epoch(mut self) -> String {
9613 self.path.push(SystemState::EPOCH_FIELD.name);
9614 self.finish()
9615 }
9616 pub fn protocol_version(mut self) -> String {
9617 self.path.push(SystemState::PROTOCOL_VERSION_FIELD.name);
9618 self.finish()
9619 }
9620 pub fn validators(mut self) -> ValidatorSetFieldPathBuilder {
9621 self.path.push(SystemState::VALIDATORS_FIELD.name);
9622 ValidatorSetFieldPathBuilder::new_with_base(self.path)
9623 }
9624 pub fn storage_fund(mut self) -> StorageFundFieldPathBuilder {
9625 self.path.push(SystemState::STORAGE_FUND_FIELD.name);
9626 StorageFundFieldPathBuilder::new_with_base(self.path)
9627 }
9628 pub fn parameters(mut self) -> SystemParametersFieldPathBuilder {
9629 self.path.push(SystemState::PARAMETERS_FIELD.name);
9630 SystemParametersFieldPathBuilder::new_with_base(self.path)
9631 }
9632 pub fn reference_gas_price(mut self) -> String {
9633 self.path.push(SystemState::REFERENCE_GAS_PRICE_FIELD.name);
9634 self.finish()
9635 }
9636 pub fn validator_report_records(
9637 mut self,
9638 ) -> ValidatorReportRecordFieldPathBuilder {
9639 self.path.push(SystemState::VALIDATOR_REPORT_RECORDS_FIELD.name);
9640 ValidatorReportRecordFieldPathBuilder::new_with_base(self.path)
9641 }
9642 pub fn stake_subsidy(mut self) -> StakeSubsidyFieldPathBuilder {
9643 self.path.push(SystemState::STAKE_SUBSIDY_FIELD.name);
9644 StakeSubsidyFieldPathBuilder::new_with_base(self.path)
9645 }
9646 pub fn safe_mode(mut self) -> String {
9647 self.path.push(SystemState::SAFE_MODE_FIELD.name);
9648 self.finish()
9649 }
9650 pub fn safe_mode_storage_rewards(mut self) -> String {
9651 self.path.push(SystemState::SAFE_MODE_STORAGE_REWARDS_FIELD.name);
9652 self.finish()
9653 }
9654 pub fn safe_mode_computation_rewards(mut self) -> String {
9655 self.path.push(SystemState::SAFE_MODE_COMPUTATION_REWARDS_FIELD.name);
9656 self.finish()
9657 }
9658 pub fn safe_mode_storage_rebates(mut self) -> String {
9659 self.path.push(SystemState::SAFE_MODE_STORAGE_REBATES_FIELD.name);
9660 self.finish()
9661 }
9662 pub fn safe_mode_non_refundable_storage_fee(mut self) -> String {
9663 self.path.push(SystemState::SAFE_MODE_NON_REFUNDABLE_STORAGE_FEE_FIELD.name);
9664 self.finish()
9665 }
9666 pub fn epoch_start_timestamp_ms(mut self) -> String {
9667 self.path.push(SystemState::EPOCH_START_TIMESTAMP_MS_FIELD.name);
9668 self.finish()
9669 }
9670 pub fn extra_fields(mut self) -> MoveTableFieldPathBuilder {
9671 self.path.push(SystemState::EXTRA_FIELDS_FIELD.name);
9672 MoveTableFieldPathBuilder::new_with_base(self.path)
9673 }
9674 }
9675 impl ValidatorReportRecord {
9676 pub const REPORTED_FIELD: &'static MessageField = &MessageField {
9677 name: "reported",
9678 json_name: "reported",
9679 number: 1i32,
9680 message_fields: None,
9681 };
9682 pub const REPORTERS_FIELD: &'static MessageField = &MessageField {
9683 name: "reporters",
9684 json_name: "reporters",
9685 number: 2i32,
9686 message_fields: None,
9687 };
9688 }
9689 impl MessageFields for ValidatorReportRecord {
9690 const FIELDS: &'static [&'static MessageField] = &[
9691 Self::REPORTED_FIELD,
9692 Self::REPORTERS_FIELD,
9693 ];
9694 }
9695 impl ValidatorReportRecord {
9696 pub fn path_builder() -> ValidatorReportRecordFieldPathBuilder {
9697 ValidatorReportRecordFieldPathBuilder::new()
9698 }
9699 }
9700 pub struct ValidatorReportRecordFieldPathBuilder {
9701 path: Vec<&'static str>,
9702 }
9703 impl ValidatorReportRecordFieldPathBuilder {
9704 #[allow(clippy::new_without_default)]
9705 pub fn new() -> Self {
9706 Self { path: Default::default() }
9707 }
9708 #[doc(hidden)]
9709 pub fn new_with_base(base: Vec<&'static str>) -> Self {
9710 Self { path: base }
9711 }
9712 pub fn finish(self) -> String {
9713 self.path.join(".")
9714 }
9715 pub fn reported(mut self) -> String {
9716 self.path.push(ValidatorReportRecord::REPORTED_FIELD.name);
9717 self.finish()
9718 }
9719 pub fn reporters(mut self) -> String {
9720 self.path.push(ValidatorReportRecord::REPORTERS_FIELD.name);
9721 self.finish()
9722 }
9723 }
9724 impl SystemParameters {
9725 pub const EPOCH_DURATION_MS_FIELD: &'static MessageField = &MessageField {
9726 name: "epoch_duration_ms",
9727 json_name: "epochDurationMs",
9728 number: 1i32,
9729 message_fields: None,
9730 };
9731 pub const STAKE_SUBSIDY_START_EPOCH_FIELD: &'static MessageField = &MessageField {
9732 name: "stake_subsidy_start_epoch",
9733 json_name: "stakeSubsidyStartEpoch",
9734 number: 2i32,
9735 message_fields: None,
9736 };
9737 pub const MIN_VALIDATOR_COUNT_FIELD: &'static MessageField = &MessageField {
9738 name: "min_validator_count",
9739 json_name: "minValidatorCount",
9740 number: 3i32,
9741 message_fields: None,
9742 };
9743 pub const MAX_VALIDATOR_COUNT_FIELD: &'static MessageField = &MessageField {
9744 name: "max_validator_count",
9745 json_name: "maxValidatorCount",
9746 number: 4i32,
9747 message_fields: None,
9748 };
9749 pub const MIN_VALIDATOR_JOINING_STAKE_FIELD: &'static MessageField = &MessageField {
9750 name: "min_validator_joining_stake",
9751 json_name: "minValidatorJoiningStake",
9752 number: 5i32,
9753 message_fields: None,
9754 };
9755 pub const VALIDATOR_LOW_STAKE_THRESHOLD_FIELD: &'static MessageField = &MessageField {
9756 name: "validator_low_stake_threshold",
9757 json_name: "validatorLowStakeThreshold",
9758 number: 6i32,
9759 message_fields: None,
9760 };
9761 pub const VALIDATOR_VERY_LOW_STAKE_THRESHOLD_FIELD: &'static MessageField = &MessageField {
9762 name: "validator_very_low_stake_threshold",
9763 json_name: "validatorVeryLowStakeThreshold",
9764 number: 7i32,
9765 message_fields: None,
9766 };
9767 pub const VALIDATOR_LOW_STAKE_GRACE_PERIOD_FIELD: &'static MessageField = &MessageField {
9768 name: "validator_low_stake_grace_period",
9769 json_name: "validatorLowStakeGracePeriod",
9770 number: 8i32,
9771 message_fields: None,
9772 };
9773 pub const EXTRA_FIELDS_FIELD: &'static MessageField = &MessageField {
9774 name: "extra_fields",
9775 json_name: "extraFields",
9776 number: 9i32,
9777 message_fields: Some(MoveTable::FIELDS),
9778 };
9779 }
9780 impl MessageFields for SystemParameters {
9781 const FIELDS: &'static [&'static MessageField] = &[
9782 Self::EPOCH_DURATION_MS_FIELD,
9783 Self::STAKE_SUBSIDY_START_EPOCH_FIELD,
9784 Self::MIN_VALIDATOR_COUNT_FIELD,
9785 Self::MAX_VALIDATOR_COUNT_FIELD,
9786 Self::MIN_VALIDATOR_JOINING_STAKE_FIELD,
9787 Self::VALIDATOR_LOW_STAKE_THRESHOLD_FIELD,
9788 Self::VALIDATOR_VERY_LOW_STAKE_THRESHOLD_FIELD,
9789 Self::VALIDATOR_LOW_STAKE_GRACE_PERIOD_FIELD,
9790 Self::EXTRA_FIELDS_FIELD,
9791 ];
9792 }
9793 impl SystemParameters {
9794 pub fn path_builder() -> SystemParametersFieldPathBuilder {
9795 SystemParametersFieldPathBuilder::new()
9796 }
9797 }
9798 pub struct SystemParametersFieldPathBuilder {
9799 path: Vec<&'static str>,
9800 }
9801 impl SystemParametersFieldPathBuilder {
9802 #[allow(clippy::new_without_default)]
9803 pub fn new() -> Self {
9804 Self { path: Default::default() }
9805 }
9806 #[doc(hidden)]
9807 pub fn new_with_base(base: Vec<&'static str>) -> Self {
9808 Self { path: base }
9809 }
9810 pub fn finish(self) -> String {
9811 self.path.join(".")
9812 }
9813 pub fn epoch_duration_ms(mut self) -> String {
9814 self.path.push(SystemParameters::EPOCH_DURATION_MS_FIELD.name);
9815 self.finish()
9816 }
9817 pub fn stake_subsidy_start_epoch(mut self) -> String {
9818 self.path.push(SystemParameters::STAKE_SUBSIDY_START_EPOCH_FIELD.name);
9819 self.finish()
9820 }
9821 pub fn min_validator_count(mut self) -> String {
9822 self.path.push(SystemParameters::MIN_VALIDATOR_COUNT_FIELD.name);
9823 self.finish()
9824 }
9825 pub fn max_validator_count(mut self) -> String {
9826 self.path.push(SystemParameters::MAX_VALIDATOR_COUNT_FIELD.name);
9827 self.finish()
9828 }
9829 pub fn min_validator_joining_stake(mut self) -> String {
9830 self.path.push(SystemParameters::MIN_VALIDATOR_JOINING_STAKE_FIELD.name);
9831 self.finish()
9832 }
9833 pub fn validator_low_stake_threshold(mut self) -> String {
9834 self.path.push(SystemParameters::VALIDATOR_LOW_STAKE_THRESHOLD_FIELD.name);
9835 self.finish()
9836 }
9837 pub fn validator_very_low_stake_threshold(mut self) -> String {
9838 self.path
9839 .push(SystemParameters::VALIDATOR_VERY_LOW_STAKE_THRESHOLD_FIELD.name);
9840 self.finish()
9841 }
9842 pub fn validator_low_stake_grace_period(mut self) -> String {
9843 self.path
9844 .push(SystemParameters::VALIDATOR_LOW_STAKE_GRACE_PERIOD_FIELD.name);
9845 self.finish()
9846 }
9847 pub fn extra_fields(mut self) -> MoveTableFieldPathBuilder {
9848 self.path.push(SystemParameters::EXTRA_FIELDS_FIELD.name);
9849 MoveTableFieldPathBuilder::new_with_base(self.path)
9850 }
9851 }
9852 impl MoveTable {
9853 pub const ID_FIELD: &'static MessageField = &MessageField {
9854 name: "id",
9855 json_name: "id",
9856 number: 1i32,
9857 message_fields: None,
9858 };
9859 pub const SIZE_FIELD: &'static MessageField = &MessageField {
9860 name: "size",
9861 json_name: "size",
9862 number: 2i32,
9863 message_fields: None,
9864 };
9865 }
9866 impl MessageFields for MoveTable {
9867 const FIELDS: &'static [&'static MessageField] = &[
9868 Self::ID_FIELD,
9869 Self::SIZE_FIELD,
9870 ];
9871 }
9872 impl MoveTable {
9873 pub fn path_builder() -> MoveTableFieldPathBuilder {
9874 MoveTableFieldPathBuilder::new()
9875 }
9876 }
9877 pub struct MoveTableFieldPathBuilder {
9878 path: Vec<&'static str>,
9879 }
9880 impl MoveTableFieldPathBuilder {
9881 #[allow(clippy::new_without_default)]
9882 pub fn new() -> Self {
9883 Self { path: Default::default() }
9884 }
9885 #[doc(hidden)]
9886 pub fn new_with_base(base: Vec<&'static str>) -> Self {
9887 Self { path: base }
9888 }
9889 pub fn finish(self) -> String {
9890 self.path.join(".")
9891 }
9892 pub fn id(mut self) -> String {
9893 self.path.push(MoveTable::ID_FIELD.name);
9894 self.finish()
9895 }
9896 pub fn size(mut self) -> String {
9897 self.path.push(MoveTable::SIZE_FIELD.name);
9898 self.finish()
9899 }
9900 }
9901 impl StakeSubsidy {
9902 pub const BALANCE_FIELD: &'static MessageField = &MessageField {
9903 name: "balance",
9904 json_name: "balance",
9905 number: 1i32,
9906 message_fields: None,
9907 };
9908 pub const DISTRIBUTION_COUNTER_FIELD: &'static MessageField = &MessageField {
9909 name: "distribution_counter",
9910 json_name: "distributionCounter",
9911 number: 2i32,
9912 message_fields: None,
9913 };
9914 pub const CURRENT_DISTRIBUTION_AMOUNT_FIELD: &'static MessageField = &MessageField {
9915 name: "current_distribution_amount",
9916 json_name: "currentDistributionAmount",
9917 number: 3i32,
9918 message_fields: None,
9919 };
9920 pub const STAKE_SUBSIDY_PERIOD_LENGTH_FIELD: &'static MessageField = &MessageField {
9921 name: "stake_subsidy_period_length",
9922 json_name: "stakeSubsidyPeriodLength",
9923 number: 4i32,
9924 message_fields: None,
9925 };
9926 pub const STAKE_SUBSIDY_DECREASE_RATE_FIELD: &'static MessageField = &MessageField {
9927 name: "stake_subsidy_decrease_rate",
9928 json_name: "stakeSubsidyDecreaseRate",
9929 number: 5i32,
9930 message_fields: None,
9931 };
9932 pub const EXTRA_FIELDS_FIELD: &'static MessageField = &MessageField {
9933 name: "extra_fields",
9934 json_name: "extraFields",
9935 number: 6i32,
9936 message_fields: Some(MoveTable::FIELDS),
9937 };
9938 }
9939 impl MessageFields for StakeSubsidy {
9940 const FIELDS: &'static [&'static MessageField] = &[
9941 Self::BALANCE_FIELD,
9942 Self::DISTRIBUTION_COUNTER_FIELD,
9943 Self::CURRENT_DISTRIBUTION_AMOUNT_FIELD,
9944 Self::STAKE_SUBSIDY_PERIOD_LENGTH_FIELD,
9945 Self::STAKE_SUBSIDY_DECREASE_RATE_FIELD,
9946 Self::EXTRA_FIELDS_FIELD,
9947 ];
9948 }
9949 impl StakeSubsidy {
9950 pub fn path_builder() -> StakeSubsidyFieldPathBuilder {
9951 StakeSubsidyFieldPathBuilder::new()
9952 }
9953 }
9954 pub struct StakeSubsidyFieldPathBuilder {
9955 path: Vec<&'static str>,
9956 }
9957 impl StakeSubsidyFieldPathBuilder {
9958 #[allow(clippy::new_without_default)]
9959 pub fn new() -> Self {
9960 Self { path: Default::default() }
9961 }
9962 #[doc(hidden)]
9963 pub fn new_with_base(base: Vec<&'static str>) -> Self {
9964 Self { path: base }
9965 }
9966 pub fn finish(self) -> String {
9967 self.path.join(".")
9968 }
9969 pub fn balance(mut self) -> String {
9970 self.path.push(StakeSubsidy::BALANCE_FIELD.name);
9971 self.finish()
9972 }
9973 pub fn distribution_counter(mut self) -> String {
9974 self.path.push(StakeSubsidy::DISTRIBUTION_COUNTER_FIELD.name);
9975 self.finish()
9976 }
9977 pub fn current_distribution_amount(mut self) -> String {
9978 self.path.push(StakeSubsidy::CURRENT_DISTRIBUTION_AMOUNT_FIELD.name);
9979 self.finish()
9980 }
9981 pub fn stake_subsidy_period_length(mut self) -> String {
9982 self.path.push(StakeSubsidy::STAKE_SUBSIDY_PERIOD_LENGTH_FIELD.name);
9983 self.finish()
9984 }
9985 pub fn stake_subsidy_decrease_rate(mut self) -> String {
9986 self.path.push(StakeSubsidy::STAKE_SUBSIDY_DECREASE_RATE_FIELD.name);
9987 self.finish()
9988 }
9989 pub fn extra_fields(mut self) -> MoveTableFieldPathBuilder {
9990 self.path.push(StakeSubsidy::EXTRA_FIELDS_FIELD.name);
9991 MoveTableFieldPathBuilder::new_with_base(self.path)
9992 }
9993 }
9994 impl StorageFund {
9995 pub const TOTAL_OBJECT_STORAGE_REBATES_FIELD: &'static MessageField = &MessageField {
9996 name: "total_object_storage_rebates",
9997 json_name: "totalObjectStorageRebates",
9998 number: 1i32,
9999 message_fields: None,
10000 };
10001 pub const NON_REFUNDABLE_BALANCE_FIELD: &'static MessageField = &MessageField {
10002 name: "non_refundable_balance",
10003 json_name: "nonRefundableBalance",
10004 number: 2i32,
10005 message_fields: None,
10006 };
10007 }
10008 impl MessageFields for StorageFund {
10009 const FIELDS: &'static [&'static MessageField] = &[
10010 Self::TOTAL_OBJECT_STORAGE_REBATES_FIELD,
10011 Self::NON_REFUNDABLE_BALANCE_FIELD,
10012 ];
10013 }
10014 impl StorageFund {
10015 pub fn path_builder() -> StorageFundFieldPathBuilder {
10016 StorageFundFieldPathBuilder::new()
10017 }
10018 }
10019 pub struct StorageFundFieldPathBuilder {
10020 path: Vec<&'static str>,
10021 }
10022 impl StorageFundFieldPathBuilder {
10023 #[allow(clippy::new_without_default)]
10024 pub fn new() -> Self {
10025 Self { path: Default::default() }
10026 }
10027 #[doc(hidden)]
10028 pub fn new_with_base(base: Vec<&'static str>) -> Self {
10029 Self { path: base }
10030 }
10031 pub fn finish(self) -> String {
10032 self.path.join(".")
10033 }
10034 pub fn total_object_storage_rebates(mut self) -> String {
10035 self.path.push(StorageFund::TOTAL_OBJECT_STORAGE_REBATES_FIELD.name);
10036 self.finish()
10037 }
10038 pub fn non_refundable_balance(mut self) -> String {
10039 self.path.push(StorageFund::NON_REFUNDABLE_BALANCE_FIELD.name);
10040 self.finish()
10041 }
10042 }
10043 impl ValidatorSet {
10044 pub const TOTAL_STAKE_FIELD: &'static MessageField = &MessageField {
10045 name: "total_stake",
10046 json_name: "totalStake",
10047 number: 1i32,
10048 message_fields: None,
10049 };
10050 pub const ACTIVE_VALIDATORS_FIELD: &'static MessageField = &MessageField {
10051 name: "active_validators",
10052 json_name: "activeValidators",
10053 number: 2i32,
10054 message_fields: Some(Validator::FIELDS),
10055 };
10056 pub const PENDING_ACTIVE_VALIDATORS_FIELD: &'static MessageField = &MessageField {
10057 name: "pending_active_validators",
10058 json_name: "pendingActiveValidators",
10059 number: 3i32,
10060 message_fields: Some(MoveTable::FIELDS),
10061 };
10062 pub const PENDING_REMOVALS_FIELD: &'static MessageField = &MessageField {
10063 name: "pending_removals",
10064 json_name: "pendingRemovals",
10065 number: 4i32,
10066 message_fields: None,
10067 };
10068 pub const STAKING_POOL_MAPPINGS_FIELD: &'static MessageField = &MessageField {
10069 name: "staking_pool_mappings",
10070 json_name: "stakingPoolMappings",
10071 number: 5i32,
10072 message_fields: Some(MoveTable::FIELDS),
10073 };
10074 pub const INACTIVE_VALIDATORS_FIELD: &'static MessageField = &MessageField {
10075 name: "inactive_validators",
10076 json_name: "inactiveValidators",
10077 number: 6i32,
10078 message_fields: Some(MoveTable::FIELDS),
10079 };
10080 pub const VALIDATOR_CANDIDATES_FIELD: &'static MessageField = &MessageField {
10081 name: "validator_candidates",
10082 json_name: "validatorCandidates",
10083 number: 7i32,
10084 message_fields: Some(MoveTable::FIELDS),
10085 };
10086 pub const AT_RISK_VALIDATORS_FIELD: &'static MessageField = &MessageField {
10087 name: "at_risk_validators",
10088 json_name: "atRiskValidators",
10089 number: 8i32,
10090 message_fields: None,
10091 };
10092 pub const EXTRA_FIELDS_FIELD: &'static MessageField = &MessageField {
10093 name: "extra_fields",
10094 json_name: "extraFields",
10095 number: 9i32,
10096 message_fields: Some(MoveTable::FIELDS),
10097 };
10098 }
10099 impl MessageFields for ValidatorSet {
10100 const FIELDS: &'static [&'static MessageField] = &[
10101 Self::TOTAL_STAKE_FIELD,
10102 Self::ACTIVE_VALIDATORS_FIELD,
10103 Self::PENDING_ACTIVE_VALIDATORS_FIELD,
10104 Self::PENDING_REMOVALS_FIELD,
10105 Self::STAKING_POOL_MAPPINGS_FIELD,
10106 Self::INACTIVE_VALIDATORS_FIELD,
10107 Self::VALIDATOR_CANDIDATES_FIELD,
10108 Self::AT_RISK_VALIDATORS_FIELD,
10109 Self::EXTRA_FIELDS_FIELD,
10110 ];
10111 }
10112 impl ValidatorSet {
10113 pub fn path_builder() -> ValidatorSetFieldPathBuilder {
10114 ValidatorSetFieldPathBuilder::new()
10115 }
10116 }
10117 pub struct ValidatorSetFieldPathBuilder {
10118 path: Vec<&'static str>,
10119 }
10120 impl ValidatorSetFieldPathBuilder {
10121 #[allow(clippy::new_without_default)]
10122 pub fn new() -> Self {
10123 Self { path: Default::default() }
10124 }
10125 #[doc(hidden)]
10126 pub fn new_with_base(base: Vec<&'static str>) -> Self {
10127 Self { path: base }
10128 }
10129 pub fn finish(self) -> String {
10130 self.path.join(".")
10131 }
10132 pub fn total_stake(mut self) -> String {
10133 self.path.push(ValidatorSet::TOTAL_STAKE_FIELD.name);
10134 self.finish()
10135 }
10136 pub fn active_validators(mut self) -> ValidatorFieldPathBuilder {
10137 self.path.push(ValidatorSet::ACTIVE_VALIDATORS_FIELD.name);
10138 ValidatorFieldPathBuilder::new_with_base(self.path)
10139 }
10140 pub fn pending_active_validators(mut self) -> MoveTableFieldPathBuilder {
10141 self.path.push(ValidatorSet::PENDING_ACTIVE_VALIDATORS_FIELD.name);
10142 MoveTableFieldPathBuilder::new_with_base(self.path)
10143 }
10144 pub fn pending_removals(mut self) -> String {
10145 self.path.push(ValidatorSet::PENDING_REMOVALS_FIELD.name);
10146 self.finish()
10147 }
10148 pub fn staking_pool_mappings(mut self) -> MoveTableFieldPathBuilder {
10149 self.path.push(ValidatorSet::STAKING_POOL_MAPPINGS_FIELD.name);
10150 MoveTableFieldPathBuilder::new_with_base(self.path)
10151 }
10152 pub fn inactive_validators(mut self) -> MoveTableFieldPathBuilder {
10153 self.path.push(ValidatorSet::INACTIVE_VALIDATORS_FIELD.name);
10154 MoveTableFieldPathBuilder::new_with_base(self.path)
10155 }
10156 pub fn validator_candidates(mut self) -> MoveTableFieldPathBuilder {
10157 self.path.push(ValidatorSet::VALIDATOR_CANDIDATES_FIELD.name);
10158 MoveTableFieldPathBuilder::new_with_base(self.path)
10159 }
10160 pub fn at_risk_validators(mut self) -> String {
10161 self.path.push(ValidatorSet::AT_RISK_VALIDATORS_FIELD.name);
10162 self.finish()
10163 }
10164 pub fn extra_fields(mut self) -> MoveTableFieldPathBuilder {
10165 self.path.push(ValidatorSet::EXTRA_FIELDS_FIELD.name);
10166 MoveTableFieldPathBuilder::new_with_base(self.path)
10167 }
10168 }
10169 impl Validator {
10170 pub const NAME_FIELD: &'static MessageField = &MessageField {
10171 name: "name",
10172 json_name: "name",
10173 number: 1i32,
10174 message_fields: None,
10175 };
10176 pub const ADDRESS_FIELD: &'static MessageField = &MessageField {
10177 name: "address",
10178 json_name: "address",
10179 number: 2i32,
10180 message_fields: None,
10181 };
10182 pub const DESCRIPTION_FIELD: &'static MessageField = &MessageField {
10183 name: "description",
10184 json_name: "description",
10185 number: 3i32,
10186 message_fields: None,
10187 };
10188 pub const IMAGE_URL_FIELD: &'static MessageField = &MessageField {
10189 name: "image_url",
10190 json_name: "imageUrl",
10191 number: 4i32,
10192 message_fields: None,
10193 };
10194 pub const PROJECT_URL_FIELD: &'static MessageField = &MessageField {
10195 name: "project_url",
10196 json_name: "projectUrl",
10197 number: 5i32,
10198 message_fields: None,
10199 };
10200 pub const PROTOCOL_PUBLIC_KEY_FIELD: &'static MessageField = &MessageField {
10201 name: "protocol_public_key",
10202 json_name: "protocolPublicKey",
10203 number: 7i32,
10204 message_fields: None,
10205 };
10206 pub const PROOF_OF_POSSESSION_FIELD: &'static MessageField = &MessageField {
10207 name: "proof_of_possession",
10208 json_name: "proofOfPossession",
10209 number: 8i32,
10210 message_fields: None,
10211 };
10212 pub const NETWORK_PUBLIC_KEY_FIELD: &'static MessageField = &MessageField {
10213 name: "network_public_key",
10214 json_name: "networkPublicKey",
10215 number: 10i32,
10216 message_fields: None,
10217 };
10218 pub const WORKER_PUBLIC_KEY_FIELD: &'static MessageField = &MessageField {
10219 name: "worker_public_key",
10220 json_name: "workerPublicKey",
10221 number: 12i32,
10222 message_fields: None,
10223 };
10224 pub const NETWORK_ADDRESS_FIELD: &'static MessageField = &MessageField {
10225 name: "network_address",
10226 json_name: "networkAddress",
10227 number: 13i32,
10228 message_fields: None,
10229 };
10230 pub const P2P_ADDRESS_FIELD: &'static MessageField = &MessageField {
10231 name: "p2p_address",
10232 json_name: "p2pAddress",
10233 number: 14i32,
10234 message_fields: None,
10235 };
10236 pub const PRIMARY_ADDRESS_FIELD: &'static MessageField = &MessageField {
10237 name: "primary_address",
10238 json_name: "primaryAddress",
10239 number: 15i32,
10240 message_fields: None,
10241 };
10242 pub const WORKER_ADDRESS_FIELD: &'static MessageField = &MessageField {
10243 name: "worker_address",
10244 json_name: "workerAddress",
10245 number: 16i32,
10246 message_fields: None,
10247 };
10248 pub const NEXT_EPOCH_PROTOCOL_PUBLIC_KEY_FIELD: &'static MessageField = &MessageField {
10249 name: "next_epoch_protocol_public_key",
10250 json_name: "nextEpochProtocolPublicKey",
10251 number: 18i32,
10252 message_fields: None,
10253 };
10254 pub const NEXT_EPOCH_PROOF_OF_POSSESSION_FIELD: &'static MessageField = &MessageField {
10255 name: "next_epoch_proof_of_possession",
10256 json_name: "nextEpochProofOfPossession",
10257 number: 19i32,
10258 message_fields: None,
10259 };
10260 pub const NEXT_EPOCH_NETWORK_PUBLIC_KEY_FIELD: &'static MessageField = &MessageField {
10261 name: "next_epoch_network_public_key",
10262 json_name: "nextEpochNetworkPublicKey",
10263 number: 21i32,
10264 message_fields: None,
10265 };
10266 pub const NEXT_EPOCH_WORKER_PUBLIC_KEY_FIELD: &'static MessageField = &MessageField {
10267 name: "next_epoch_worker_public_key",
10268 json_name: "nextEpochWorkerPublicKey",
10269 number: 23i32,
10270 message_fields: None,
10271 };
10272 pub const NEXT_EPOCH_NETWORK_ADDRESS_FIELD: &'static MessageField = &MessageField {
10273 name: "next_epoch_network_address",
10274 json_name: "nextEpochNetworkAddress",
10275 number: 24i32,
10276 message_fields: None,
10277 };
10278 pub const NEXT_EPOCH_P2P_ADDRESS_FIELD: &'static MessageField = &MessageField {
10279 name: "next_epoch_p2p_address",
10280 json_name: "nextEpochP2pAddress",
10281 number: 25i32,
10282 message_fields: None,
10283 };
10284 pub const NEXT_EPOCH_PRIMARY_ADDRESS_FIELD: &'static MessageField = &MessageField {
10285 name: "next_epoch_primary_address",
10286 json_name: "nextEpochPrimaryAddress",
10287 number: 26i32,
10288 message_fields: None,
10289 };
10290 pub const NEXT_EPOCH_WORKER_ADDRESS_FIELD: &'static MessageField = &MessageField {
10291 name: "next_epoch_worker_address",
10292 json_name: "nextEpochWorkerAddress",
10293 number: 27i32,
10294 message_fields: None,
10295 };
10296 pub const METADATA_EXTRA_FIELDS_FIELD: &'static MessageField = &MessageField {
10297 name: "metadata_extra_fields",
10298 json_name: "metadataExtraFields",
10299 number: 28i32,
10300 message_fields: Some(MoveTable::FIELDS),
10301 };
10302 pub const VOTING_POWER_FIELD: &'static MessageField = &MessageField {
10303 name: "voting_power",
10304 json_name: "votingPower",
10305 number: 29i32,
10306 message_fields: None,
10307 };
10308 pub const OPERATION_CAP_ID_FIELD: &'static MessageField = &MessageField {
10309 name: "operation_cap_id",
10310 json_name: "operationCapId",
10311 number: 30i32,
10312 message_fields: None,
10313 };
10314 pub const GAS_PRICE_FIELD: &'static MessageField = &MessageField {
10315 name: "gas_price",
10316 json_name: "gasPrice",
10317 number: 31i32,
10318 message_fields: None,
10319 };
10320 pub const STAKING_POOL_FIELD: &'static MessageField = &MessageField {
10321 name: "staking_pool",
10322 json_name: "stakingPool",
10323 number: 32i32,
10324 message_fields: Some(StakingPool::FIELDS),
10325 };
10326 pub const COMMISSION_RATE_FIELD: &'static MessageField = &MessageField {
10327 name: "commission_rate",
10328 json_name: "commissionRate",
10329 number: 33i32,
10330 message_fields: None,
10331 };
10332 pub const NEXT_EPOCH_STAKE_FIELD: &'static MessageField = &MessageField {
10333 name: "next_epoch_stake",
10334 json_name: "nextEpochStake",
10335 number: 34i32,
10336 message_fields: None,
10337 };
10338 pub const NEXT_EPOCH_GAS_PRICE_FIELD: &'static MessageField = &MessageField {
10339 name: "next_epoch_gas_price",
10340 json_name: "nextEpochGasPrice",
10341 number: 35i32,
10342 message_fields: None,
10343 };
10344 pub const NEXT_EPOCH_COMMISSION_RATE_FIELD: &'static MessageField = &MessageField {
10345 name: "next_epoch_commission_rate",
10346 json_name: "nextEpochCommissionRate",
10347 number: 36i32,
10348 message_fields: None,
10349 };
10350 pub const EXTRA_FIELDS_FIELD: &'static MessageField = &MessageField {
10351 name: "extra_fields",
10352 json_name: "extraFields",
10353 number: 37i32,
10354 message_fields: Some(MoveTable::FIELDS),
10355 };
10356 }
10357 impl MessageFields for Validator {
10358 const FIELDS: &'static [&'static MessageField] = &[
10359 Self::NAME_FIELD,
10360 Self::ADDRESS_FIELD,
10361 Self::DESCRIPTION_FIELD,
10362 Self::IMAGE_URL_FIELD,
10363 Self::PROJECT_URL_FIELD,
10364 Self::PROTOCOL_PUBLIC_KEY_FIELD,
10365 Self::PROOF_OF_POSSESSION_FIELD,
10366 Self::NETWORK_PUBLIC_KEY_FIELD,
10367 Self::WORKER_PUBLIC_KEY_FIELD,
10368 Self::NETWORK_ADDRESS_FIELD,
10369 Self::P2P_ADDRESS_FIELD,
10370 Self::PRIMARY_ADDRESS_FIELD,
10371 Self::WORKER_ADDRESS_FIELD,
10372 Self::NEXT_EPOCH_PROTOCOL_PUBLIC_KEY_FIELD,
10373 Self::NEXT_EPOCH_PROOF_OF_POSSESSION_FIELD,
10374 Self::NEXT_EPOCH_NETWORK_PUBLIC_KEY_FIELD,
10375 Self::NEXT_EPOCH_WORKER_PUBLIC_KEY_FIELD,
10376 Self::NEXT_EPOCH_NETWORK_ADDRESS_FIELD,
10377 Self::NEXT_EPOCH_P2P_ADDRESS_FIELD,
10378 Self::NEXT_EPOCH_PRIMARY_ADDRESS_FIELD,
10379 Self::NEXT_EPOCH_WORKER_ADDRESS_FIELD,
10380 Self::METADATA_EXTRA_FIELDS_FIELD,
10381 Self::VOTING_POWER_FIELD,
10382 Self::OPERATION_CAP_ID_FIELD,
10383 Self::GAS_PRICE_FIELD,
10384 Self::STAKING_POOL_FIELD,
10385 Self::COMMISSION_RATE_FIELD,
10386 Self::NEXT_EPOCH_STAKE_FIELD,
10387 Self::NEXT_EPOCH_GAS_PRICE_FIELD,
10388 Self::NEXT_EPOCH_COMMISSION_RATE_FIELD,
10389 Self::EXTRA_FIELDS_FIELD,
10390 ];
10391 }
10392 impl Validator {
10393 pub fn path_builder() -> ValidatorFieldPathBuilder {
10394 ValidatorFieldPathBuilder::new()
10395 }
10396 }
10397 pub struct ValidatorFieldPathBuilder {
10398 path: Vec<&'static str>,
10399 }
10400 impl ValidatorFieldPathBuilder {
10401 #[allow(clippy::new_without_default)]
10402 pub fn new() -> Self {
10403 Self { path: Default::default() }
10404 }
10405 #[doc(hidden)]
10406 pub fn new_with_base(base: Vec<&'static str>) -> Self {
10407 Self { path: base }
10408 }
10409 pub fn finish(self) -> String {
10410 self.path.join(".")
10411 }
10412 pub fn name(mut self) -> String {
10413 self.path.push(Validator::NAME_FIELD.name);
10414 self.finish()
10415 }
10416 pub fn address(mut self) -> String {
10417 self.path.push(Validator::ADDRESS_FIELD.name);
10418 self.finish()
10419 }
10420 pub fn description(mut self) -> String {
10421 self.path.push(Validator::DESCRIPTION_FIELD.name);
10422 self.finish()
10423 }
10424 pub fn image_url(mut self) -> String {
10425 self.path.push(Validator::IMAGE_URL_FIELD.name);
10426 self.finish()
10427 }
10428 pub fn project_url(mut self) -> String {
10429 self.path.push(Validator::PROJECT_URL_FIELD.name);
10430 self.finish()
10431 }
10432 pub fn protocol_public_key(mut self) -> String {
10433 self.path.push(Validator::PROTOCOL_PUBLIC_KEY_FIELD.name);
10434 self.finish()
10435 }
10436 pub fn proof_of_possession(mut self) -> String {
10437 self.path.push(Validator::PROOF_OF_POSSESSION_FIELD.name);
10438 self.finish()
10439 }
10440 pub fn network_public_key(mut self) -> String {
10441 self.path.push(Validator::NETWORK_PUBLIC_KEY_FIELD.name);
10442 self.finish()
10443 }
10444 pub fn worker_public_key(mut self) -> String {
10445 self.path.push(Validator::WORKER_PUBLIC_KEY_FIELD.name);
10446 self.finish()
10447 }
10448 pub fn network_address(mut self) -> String {
10449 self.path.push(Validator::NETWORK_ADDRESS_FIELD.name);
10450 self.finish()
10451 }
10452 pub fn p2p_address(mut self) -> String {
10453 self.path.push(Validator::P2P_ADDRESS_FIELD.name);
10454 self.finish()
10455 }
10456 pub fn primary_address(mut self) -> String {
10457 self.path.push(Validator::PRIMARY_ADDRESS_FIELD.name);
10458 self.finish()
10459 }
10460 pub fn worker_address(mut self) -> String {
10461 self.path.push(Validator::WORKER_ADDRESS_FIELD.name);
10462 self.finish()
10463 }
10464 pub fn next_epoch_protocol_public_key(mut self) -> String {
10465 self.path.push(Validator::NEXT_EPOCH_PROTOCOL_PUBLIC_KEY_FIELD.name);
10466 self.finish()
10467 }
10468 pub fn next_epoch_proof_of_possession(mut self) -> String {
10469 self.path.push(Validator::NEXT_EPOCH_PROOF_OF_POSSESSION_FIELD.name);
10470 self.finish()
10471 }
10472 pub fn next_epoch_network_public_key(mut self) -> String {
10473 self.path.push(Validator::NEXT_EPOCH_NETWORK_PUBLIC_KEY_FIELD.name);
10474 self.finish()
10475 }
10476 pub fn next_epoch_worker_public_key(mut self) -> String {
10477 self.path.push(Validator::NEXT_EPOCH_WORKER_PUBLIC_KEY_FIELD.name);
10478 self.finish()
10479 }
10480 pub fn next_epoch_network_address(mut self) -> String {
10481 self.path.push(Validator::NEXT_EPOCH_NETWORK_ADDRESS_FIELD.name);
10482 self.finish()
10483 }
10484 pub fn next_epoch_p2p_address(mut self) -> String {
10485 self.path.push(Validator::NEXT_EPOCH_P2P_ADDRESS_FIELD.name);
10486 self.finish()
10487 }
10488 pub fn next_epoch_primary_address(mut self) -> String {
10489 self.path.push(Validator::NEXT_EPOCH_PRIMARY_ADDRESS_FIELD.name);
10490 self.finish()
10491 }
10492 pub fn next_epoch_worker_address(mut self) -> String {
10493 self.path.push(Validator::NEXT_EPOCH_WORKER_ADDRESS_FIELD.name);
10494 self.finish()
10495 }
10496 pub fn metadata_extra_fields(mut self) -> MoveTableFieldPathBuilder {
10497 self.path.push(Validator::METADATA_EXTRA_FIELDS_FIELD.name);
10498 MoveTableFieldPathBuilder::new_with_base(self.path)
10499 }
10500 pub fn voting_power(mut self) -> String {
10501 self.path.push(Validator::VOTING_POWER_FIELD.name);
10502 self.finish()
10503 }
10504 pub fn operation_cap_id(mut self) -> String {
10505 self.path.push(Validator::OPERATION_CAP_ID_FIELD.name);
10506 self.finish()
10507 }
10508 pub fn gas_price(mut self) -> String {
10509 self.path.push(Validator::GAS_PRICE_FIELD.name);
10510 self.finish()
10511 }
10512 pub fn staking_pool(mut self) -> StakingPoolFieldPathBuilder {
10513 self.path.push(Validator::STAKING_POOL_FIELD.name);
10514 StakingPoolFieldPathBuilder::new_with_base(self.path)
10515 }
10516 pub fn commission_rate(mut self) -> String {
10517 self.path.push(Validator::COMMISSION_RATE_FIELD.name);
10518 self.finish()
10519 }
10520 pub fn next_epoch_stake(mut self) -> String {
10521 self.path.push(Validator::NEXT_EPOCH_STAKE_FIELD.name);
10522 self.finish()
10523 }
10524 pub fn next_epoch_gas_price(mut self) -> String {
10525 self.path.push(Validator::NEXT_EPOCH_GAS_PRICE_FIELD.name);
10526 self.finish()
10527 }
10528 pub fn next_epoch_commission_rate(mut self) -> String {
10529 self.path.push(Validator::NEXT_EPOCH_COMMISSION_RATE_FIELD.name);
10530 self.finish()
10531 }
10532 pub fn extra_fields(mut self) -> MoveTableFieldPathBuilder {
10533 self.path.push(Validator::EXTRA_FIELDS_FIELD.name);
10534 MoveTableFieldPathBuilder::new_with_base(self.path)
10535 }
10536 }
10537 impl StakingPool {
10538 pub const ID_FIELD: &'static MessageField = &MessageField {
10539 name: "id",
10540 json_name: "id",
10541 number: 1i32,
10542 message_fields: None,
10543 };
10544 pub const ACTIVATION_EPOCH_FIELD: &'static MessageField = &MessageField {
10545 name: "activation_epoch",
10546 json_name: "activationEpoch",
10547 number: 2i32,
10548 message_fields: None,
10549 };
10550 pub const DEACTIVATION_EPOCH_FIELD: &'static MessageField = &MessageField {
10551 name: "deactivation_epoch",
10552 json_name: "deactivationEpoch",
10553 number: 3i32,
10554 message_fields: None,
10555 };
10556 pub const SUI_BALANCE_FIELD: &'static MessageField = &MessageField {
10557 name: "sui_balance",
10558 json_name: "suiBalance",
10559 number: 4i32,
10560 message_fields: None,
10561 };
10562 pub const REWARDS_POOL_FIELD: &'static MessageField = &MessageField {
10563 name: "rewards_pool",
10564 json_name: "rewardsPool",
10565 number: 5i32,
10566 message_fields: None,
10567 };
10568 pub const POOL_TOKEN_BALANCE_FIELD: &'static MessageField = &MessageField {
10569 name: "pool_token_balance",
10570 json_name: "poolTokenBalance",
10571 number: 6i32,
10572 message_fields: None,
10573 };
10574 pub const EXCHANGE_RATES_FIELD: &'static MessageField = &MessageField {
10575 name: "exchange_rates",
10576 json_name: "exchangeRates",
10577 number: 7i32,
10578 message_fields: Some(MoveTable::FIELDS),
10579 };
10580 pub const PENDING_STAKE_FIELD: &'static MessageField = &MessageField {
10581 name: "pending_stake",
10582 json_name: "pendingStake",
10583 number: 8i32,
10584 message_fields: None,
10585 };
10586 pub const PENDING_TOTAL_SUI_WITHDRAW_FIELD: &'static MessageField = &MessageField {
10587 name: "pending_total_sui_withdraw",
10588 json_name: "pendingTotalSuiWithdraw",
10589 number: 9i32,
10590 message_fields: None,
10591 };
10592 pub const PENDING_POOL_TOKEN_WITHDRAW_FIELD: &'static MessageField = &MessageField {
10593 name: "pending_pool_token_withdraw",
10594 json_name: "pendingPoolTokenWithdraw",
10595 number: 10i32,
10596 message_fields: None,
10597 };
10598 pub const EXTRA_FIELDS_FIELD: &'static MessageField = &MessageField {
10599 name: "extra_fields",
10600 json_name: "extraFields",
10601 number: 11i32,
10602 message_fields: Some(MoveTable::FIELDS),
10603 };
10604 }
10605 impl MessageFields for StakingPool {
10606 const FIELDS: &'static [&'static MessageField] = &[
10607 Self::ID_FIELD,
10608 Self::ACTIVATION_EPOCH_FIELD,
10609 Self::DEACTIVATION_EPOCH_FIELD,
10610 Self::SUI_BALANCE_FIELD,
10611 Self::REWARDS_POOL_FIELD,
10612 Self::POOL_TOKEN_BALANCE_FIELD,
10613 Self::EXCHANGE_RATES_FIELD,
10614 Self::PENDING_STAKE_FIELD,
10615 Self::PENDING_TOTAL_SUI_WITHDRAW_FIELD,
10616 Self::PENDING_POOL_TOKEN_WITHDRAW_FIELD,
10617 Self::EXTRA_FIELDS_FIELD,
10618 ];
10619 }
10620 impl StakingPool {
10621 pub fn path_builder() -> StakingPoolFieldPathBuilder {
10622 StakingPoolFieldPathBuilder::new()
10623 }
10624 }
10625 pub struct StakingPoolFieldPathBuilder {
10626 path: Vec<&'static str>,
10627 }
10628 impl StakingPoolFieldPathBuilder {
10629 #[allow(clippy::new_without_default)]
10630 pub fn new() -> Self {
10631 Self { path: Default::default() }
10632 }
10633 #[doc(hidden)]
10634 pub fn new_with_base(base: Vec<&'static str>) -> Self {
10635 Self { path: base }
10636 }
10637 pub fn finish(self) -> String {
10638 self.path.join(".")
10639 }
10640 pub fn id(mut self) -> String {
10641 self.path.push(StakingPool::ID_FIELD.name);
10642 self.finish()
10643 }
10644 pub fn activation_epoch(mut self) -> String {
10645 self.path.push(StakingPool::ACTIVATION_EPOCH_FIELD.name);
10646 self.finish()
10647 }
10648 pub fn deactivation_epoch(mut self) -> String {
10649 self.path.push(StakingPool::DEACTIVATION_EPOCH_FIELD.name);
10650 self.finish()
10651 }
10652 pub fn sui_balance(mut self) -> String {
10653 self.path.push(StakingPool::SUI_BALANCE_FIELD.name);
10654 self.finish()
10655 }
10656 pub fn rewards_pool(mut self) -> String {
10657 self.path.push(StakingPool::REWARDS_POOL_FIELD.name);
10658 self.finish()
10659 }
10660 pub fn pool_token_balance(mut self) -> String {
10661 self.path.push(StakingPool::POOL_TOKEN_BALANCE_FIELD.name);
10662 self.finish()
10663 }
10664 pub fn exchange_rates(mut self) -> MoveTableFieldPathBuilder {
10665 self.path.push(StakingPool::EXCHANGE_RATES_FIELD.name);
10666 MoveTableFieldPathBuilder::new_with_base(self.path)
10667 }
10668 pub fn pending_stake(mut self) -> String {
10669 self.path.push(StakingPool::PENDING_STAKE_FIELD.name);
10670 self.finish()
10671 }
10672 pub fn pending_total_sui_withdraw(mut self) -> String {
10673 self.path.push(StakingPool::PENDING_TOTAL_SUI_WITHDRAW_FIELD.name);
10674 self.finish()
10675 }
10676 pub fn pending_pool_token_withdraw(mut self) -> String {
10677 self.path.push(StakingPool::PENDING_POOL_TOKEN_WITHDRAW_FIELD.name);
10678 self.finish()
10679 }
10680 pub fn extra_fields(mut self) -> MoveTableFieldPathBuilder {
10681 self.path.push(StakingPool::EXTRA_FIELDS_FIELD.name);
10682 MoveTableFieldPathBuilder::new_with_base(self.path)
10683 }
10684 }
10685 impl Transaction {
10686 pub const BCS_FIELD: &'static MessageField = &MessageField {
10687 name: "bcs",
10688 json_name: "bcs",
10689 number: 1i32,
10690 message_fields: Some(Bcs::FIELDS),
10691 };
10692 pub const DIGEST_FIELD: &'static MessageField = &MessageField {
10693 name: "digest",
10694 json_name: "digest",
10695 number: 2i32,
10696 message_fields: None,
10697 };
10698 pub const VERSION_FIELD: &'static MessageField = &MessageField {
10699 name: "version",
10700 json_name: "version",
10701 number: 3i32,
10702 message_fields: None,
10703 };
10704 pub const KIND_FIELD: &'static MessageField = &MessageField {
10705 name: "kind",
10706 json_name: "kind",
10707 number: 4i32,
10708 message_fields: Some(TransactionKind::FIELDS),
10709 };
10710 pub const SENDER_FIELD: &'static MessageField = &MessageField {
10711 name: "sender",
10712 json_name: "sender",
10713 number: 5i32,
10714 message_fields: None,
10715 };
10716 pub const GAS_PAYMENT_FIELD: &'static MessageField = &MessageField {
10717 name: "gas_payment",
10718 json_name: "gasPayment",
10719 number: 6i32,
10720 message_fields: Some(GasPayment::FIELDS),
10721 };
10722 pub const EXPIRATION_FIELD: &'static MessageField = &MessageField {
10723 name: "expiration",
10724 json_name: "expiration",
10725 number: 7i32,
10726 message_fields: Some(TransactionExpiration::FIELDS),
10727 };
10728 }
10729 impl MessageFields for Transaction {
10730 const FIELDS: &'static [&'static MessageField] = &[
10731 Self::BCS_FIELD,
10732 Self::DIGEST_FIELD,
10733 Self::VERSION_FIELD,
10734 Self::KIND_FIELD,
10735 Self::SENDER_FIELD,
10736 Self::GAS_PAYMENT_FIELD,
10737 Self::EXPIRATION_FIELD,
10738 ];
10739 }
10740 impl Transaction {
10741 pub fn path_builder() -> TransactionFieldPathBuilder {
10742 TransactionFieldPathBuilder::new()
10743 }
10744 }
10745 pub struct TransactionFieldPathBuilder {
10746 path: Vec<&'static str>,
10747 }
10748 impl TransactionFieldPathBuilder {
10749 #[allow(clippy::new_without_default)]
10750 pub fn new() -> Self {
10751 Self { path: Default::default() }
10752 }
10753 #[doc(hidden)]
10754 pub fn new_with_base(base: Vec<&'static str>) -> Self {
10755 Self { path: base }
10756 }
10757 pub fn finish(self) -> String {
10758 self.path.join(".")
10759 }
10760 pub fn bcs(mut self) -> BcsFieldPathBuilder {
10761 self.path.push(Transaction::BCS_FIELD.name);
10762 BcsFieldPathBuilder::new_with_base(self.path)
10763 }
10764 pub fn digest(mut self) -> String {
10765 self.path.push(Transaction::DIGEST_FIELD.name);
10766 self.finish()
10767 }
10768 pub fn version(mut self) -> String {
10769 self.path.push(Transaction::VERSION_FIELD.name);
10770 self.finish()
10771 }
10772 pub fn kind(mut self) -> TransactionKindFieldPathBuilder {
10773 self.path.push(Transaction::KIND_FIELD.name);
10774 TransactionKindFieldPathBuilder::new_with_base(self.path)
10775 }
10776 pub fn sender(mut self) -> String {
10777 self.path.push(Transaction::SENDER_FIELD.name);
10778 self.finish()
10779 }
10780 pub fn gas_payment(mut self) -> GasPaymentFieldPathBuilder {
10781 self.path.push(Transaction::GAS_PAYMENT_FIELD.name);
10782 GasPaymentFieldPathBuilder::new_with_base(self.path)
10783 }
10784 pub fn expiration(mut self) -> TransactionExpirationFieldPathBuilder {
10785 self.path.push(Transaction::EXPIRATION_FIELD.name);
10786 TransactionExpirationFieldPathBuilder::new_with_base(self.path)
10787 }
10788 }
10789 impl GasPayment {
10790 pub const OBJECTS_FIELD: &'static MessageField = &MessageField {
10791 name: "objects",
10792 json_name: "objects",
10793 number: 1i32,
10794 message_fields: Some(ObjectReference::FIELDS),
10795 };
10796 pub const OWNER_FIELD: &'static MessageField = &MessageField {
10797 name: "owner",
10798 json_name: "owner",
10799 number: 2i32,
10800 message_fields: None,
10801 };
10802 pub const PRICE_FIELD: &'static MessageField = &MessageField {
10803 name: "price",
10804 json_name: "price",
10805 number: 3i32,
10806 message_fields: None,
10807 };
10808 pub const BUDGET_FIELD: &'static MessageField = &MessageField {
10809 name: "budget",
10810 json_name: "budget",
10811 number: 4i32,
10812 message_fields: None,
10813 };
10814 }
10815 impl MessageFields for GasPayment {
10816 const FIELDS: &'static [&'static MessageField] = &[
10817 Self::OBJECTS_FIELD,
10818 Self::OWNER_FIELD,
10819 Self::PRICE_FIELD,
10820 Self::BUDGET_FIELD,
10821 ];
10822 }
10823 impl GasPayment {
10824 pub fn path_builder() -> GasPaymentFieldPathBuilder {
10825 GasPaymentFieldPathBuilder::new()
10826 }
10827 }
10828 pub struct GasPaymentFieldPathBuilder {
10829 path: Vec<&'static str>,
10830 }
10831 impl GasPaymentFieldPathBuilder {
10832 #[allow(clippy::new_without_default)]
10833 pub fn new() -> Self {
10834 Self { path: Default::default() }
10835 }
10836 #[doc(hidden)]
10837 pub fn new_with_base(base: Vec<&'static str>) -> Self {
10838 Self { path: base }
10839 }
10840 pub fn finish(self) -> String {
10841 self.path.join(".")
10842 }
10843 pub fn objects(mut self) -> ObjectReferenceFieldPathBuilder {
10844 self.path.push(GasPayment::OBJECTS_FIELD.name);
10845 ObjectReferenceFieldPathBuilder::new_with_base(self.path)
10846 }
10847 pub fn owner(mut self) -> String {
10848 self.path.push(GasPayment::OWNER_FIELD.name);
10849 self.finish()
10850 }
10851 pub fn price(mut self) -> String {
10852 self.path.push(GasPayment::PRICE_FIELD.name);
10853 self.finish()
10854 }
10855 pub fn budget(mut self) -> String {
10856 self.path.push(GasPayment::BUDGET_FIELD.name);
10857 self.finish()
10858 }
10859 }
10860 impl TransactionExpiration {
10861 pub const KIND_FIELD: &'static MessageField = &MessageField {
10862 name: "kind",
10863 json_name: "kind",
10864 number: 1i32,
10865 message_fields: None,
10866 };
10867 pub const EPOCH_FIELD: &'static MessageField = &MessageField {
10868 name: "epoch",
10869 json_name: "epoch",
10870 number: 2i32,
10871 message_fields: None,
10872 };
10873 pub const MIN_EPOCH_FIELD: &'static MessageField = &MessageField {
10874 name: "min_epoch",
10875 json_name: "minEpoch",
10876 number: 3i32,
10877 message_fields: None,
10878 };
10879 pub const MIN_TIMESTAMP_FIELD: &'static MessageField = &MessageField {
10880 name: "min_timestamp",
10881 json_name: "minTimestamp",
10882 number: 4i32,
10883 message_fields: None,
10884 };
10885 pub const MAX_TIMESTAMP_FIELD: &'static MessageField = &MessageField {
10886 name: "max_timestamp",
10887 json_name: "maxTimestamp",
10888 number: 5i32,
10889 message_fields: None,
10890 };
10891 pub const CHAIN_FIELD: &'static MessageField = &MessageField {
10892 name: "chain",
10893 json_name: "chain",
10894 number: 6i32,
10895 message_fields: None,
10896 };
10897 pub const NONCE_FIELD: &'static MessageField = &MessageField {
10898 name: "nonce",
10899 json_name: "nonce",
10900 number: 7i32,
10901 message_fields: None,
10902 };
10903 pub const ALLOWED_PROPOSERS_FIELD: &'static MessageField = &MessageField {
10904 name: "allowed_proposers",
10905 json_name: "allowedProposers",
10906 number: 8i32,
10907 message_fields: Some(AllowedProposers::FIELDS),
10908 };
10909 }
10910 impl MessageFields for TransactionExpiration {
10911 const FIELDS: &'static [&'static MessageField] = &[
10912 Self::KIND_FIELD,
10913 Self::EPOCH_FIELD,
10914 Self::MIN_EPOCH_FIELD,
10915 Self::MIN_TIMESTAMP_FIELD,
10916 Self::MAX_TIMESTAMP_FIELD,
10917 Self::CHAIN_FIELD,
10918 Self::NONCE_FIELD,
10919 Self::ALLOWED_PROPOSERS_FIELD,
10920 ];
10921 }
10922 impl TransactionExpiration {
10923 pub fn path_builder() -> TransactionExpirationFieldPathBuilder {
10924 TransactionExpirationFieldPathBuilder::new()
10925 }
10926 }
10927 pub struct TransactionExpirationFieldPathBuilder {
10928 path: Vec<&'static str>,
10929 }
10930 impl TransactionExpirationFieldPathBuilder {
10931 #[allow(clippy::new_without_default)]
10932 pub fn new() -> Self {
10933 Self { path: Default::default() }
10934 }
10935 #[doc(hidden)]
10936 pub fn new_with_base(base: Vec<&'static str>) -> Self {
10937 Self { path: base }
10938 }
10939 pub fn finish(self) -> String {
10940 self.path.join(".")
10941 }
10942 pub fn kind(mut self) -> String {
10943 self.path.push(TransactionExpiration::KIND_FIELD.name);
10944 self.finish()
10945 }
10946 pub fn epoch(mut self) -> String {
10947 self.path.push(TransactionExpiration::EPOCH_FIELD.name);
10948 self.finish()
10949 }
10950 pub fn min_epoch(mut self) -> String {
10951 self.path.push(TransactionExpiration::MIN_EPOCH_FIELD.name);
10952 self.finish()
10953 }
10954 pub fn min_timestamp(mut self) -> String {
10955 self.path.push(TransactionExpiration::MIN_TIMESTAMP_FIELD.name);
10956 self.finish()
10957 }
10958 pub fn max_timestamp(mut self) -> String {
10959 self.path.push(TransactionExpiration::MAX_TIMESTAMP_FIELD.name);
10960 self.finish()
10961 }
10962 pub fn chain(mut self) -> String {
10963 self.path.push(TransactionExpiration::CHAIN_FIELD.name);
10964 self.finish()
10965 }
10966 pub fn nonce(mut self) -> String {
10967 self.path.push(TransactionExpiration::NONCE_FIELD.name);
10968 self.finish()
10969 }
10970 pub fn allowed_proposers(mut self) -> AllowedProposersFieldPathBuilder {
10971 self.path.push(TransactionExpiration::ALLOWED_PROPOSERS_FIELD.name);
10972 AllowedProposersFieldPathBuilder::new_with_base(self.path)
10973 }
10974 }
10975 impl AllowedProposers {
10976 pub const EPOCH_FIELD: &'static MessageField = &MessageField {
10977 name: "epoch",
10978 json_name: "epoch",
10979 number: 1i32,
10980 message_fields: None,
10981 };
10982 pub const PROPOSERS_FIELD: &'static MessageField = &MessageField {
10983 name: "proposers",
10984 json_name: "proposers",
10985 number: 2i32,
10986 message_fields: None,
10987 };
10988 }
10989 impl MessageFields for AllowedProposers {
10990 const FIELDS: &'static [&'static MessageField] = &[
10991 Self::EPOCH_FIELD,
10992 Self::PROPOSERS_FIELD,
10993 ];
10994 }
10995 impl AllowedProposers {
10996 pub fn path_builder() -> AllowedProposersFieldPathBuilder {
10997 AllowedProposersFieldPathBuilder::new()
10998 }
10999 }
11000 pub struct AllowedProposersFieldPathBuilder {
11001 path: Vec<&'static str>,
11002 }
11003 impl AllowedProposersFieldPathBuilder {
11004 #[allow(clippy::new_without_default)]
11005 pub fn new() -> Self {
11006 Self { path: Default::default() }
11007 }
11008 #[doc(hidden)]
11009 pub fn new_with_base(base: Vec<&'static str>) -> Self {
11010 Self { path: base }
11011 }
11012 pub fn finish(self) -> String {
11013 self.path.join(".")
11014 }
11015 pub fn epoch(mut self) -> String {
11016 self.path.push(AllowedProposers::EPOCH_FIELD.name);
11017 self.finish()
11018 }
11019 pub fn proposers(mut self) -> String {
11020 self.path.push(AllowedProposers::PROPOSERS_FIELD.name);
11021 self.finish()
11022 }
11023 }
11024 impl TransactionKind {
11025 pub const KIND_FIELD: &'static MessageField = &MessageField {
11026 name: "kind",
11027 json_name: "kind",
11028 number: 1i32,
11029 message_fields: None,
11030 };
11031 pub const PROGRAMMABLE_TRANSACTION_FIELD: &'static MessageField = &MessageField {
11032 name: "programmable_transaction",
11033 json_name: "programmableTransaction",
11034 number: 2i32,
11035 message_fields: Some(ProgrammableTransaction::FIELDS),
11036 };
11037 pub const CHANGE_EPOCH_FIELD: &'static MessageField = &MessageField {
11038 name: "change_epoch",
11039 json_name: "changeEpoch",
11040 number: 3i32,
11041 message_fields: Some(ChangeEpoch::FIELDS),
11042 };
11043 pub const GENESIS_FIELD: &'static MessageField = &MessageField {
11044 name: "genesis",
11045 json_name: "genesis",
11046 number: 4i32,
11047 message_fields: Some(GenesisTransaction::FIELDS),
11048 };
11049 pub const CONSENSUS_COMMIT_PROLOGUE_FIELD: &'static MessageField = &MessageField {
11050 name: "consensus_commit_prologue",
11051 json_name: "consensusCommitPrologue",
11052 number: 5i32,
11053 message_fields: Some(ConsensusCommitPrologue::FIELDS),
11054 };
11055 pub const AUTHENTICATOR_STATE_UPDATE_FIELD: &'static MessageField = &MessageField {
11056 name: "authenticator_state_update",
11057 json_name: "authenticatorStateUpdate",
11058 number: 6i32,
11059 message_fields: Some(AuthenticatorStateUpdate::FIELDS),
11060 };
11061 pub const END_OF_EPOCH_FIELD: &'static MessageField = &MessageField {
11062 name: "end_of_epoch",
11063 json_name: "endOfEpoch",
11064 number: 7i32,
11065 message_fields: Some(EndOfEpochTransaction::FIELDS),
11066 };
11067 pub const RANDOMNESS_STATE_UPDATE_FIELD: &'static MessageField = &MessageField {
11068 name: "randomness_state_update",
11069 json_name: "randomnessStateUpdate",
11070 number: 8i32,
11071 message_fields: Some(RandomnessStateUpdate::FIELDS),
11072 };
11073 }
11074 impl MessageFields for TransactionKind {
11075 const FIELDS: &'static [&'static MessageField] = &[
11076 Self::KIND_FIELD,
11077 Self::PROGRAMMABLE_TRANSACTION_FIELD,
11078 Self::CHANGE_EPOCH_FIELD,
11079 Self::GENESIS_FIELD,
11080 Self::CONSENSUS_COMMIT_PROLOGUE_FIELD,
11081 Self::AUTHENTICATOR_STATE_UPDATE_FIELD,
11082 Self::END_OF_EPOCH_FIELD,
11083 Self::RANDOMNESS_STATE_UPDATE_FIELD,
11084 ];
11085 }
11086 impl TransactionKind {
11087 pub fn path_builder() -> TransactionKindFieldPathBuilder {
11088 TransactionKindFieldPathBuilder::new()
11089 }
11090 }
11091 pub struct TransactionKindFieldPathBuilder {
11092 path: Vec<&'static str>,
11093 }
11094 impl TransactionKindFieldPathBuilder {
11095 #[allow(clippy::new_without_default)]
11096 pub fn new() -> Self {
11097 Self { path: Default::default() }
11098 }
11099 #[doc(hidden)]
11100 pub fn new_with_base(base: Vec<&'static str>) -> Self {
11101 Self { path: base }
11102 }
11103 pub fn finish(self) -> String {
11104 self.path.join(".")
11105 }
11106 pub fn kind(mut self) -> String {
11107 self.path.push(TransactionKind::KIND_FIELD.name);
11108 self.finish()
11109 }
11110 pub fn programmable_transaction(
11111 mut self,
11112 ) -> ProgrammableTransactionFieldPathBuilder {
11113 self.path.push(TransactionKind::PROGRAMMABLE_TRANSACTION_FIELD.name);
11114 ProgrammableTransactionFieldPathBuilder::new_with_base(self.path)
11115 }
11116 pub fn change_epoch(mut self) -> ChangeEpochFieldPathBuilder {
11117 self.path.push(TransactionKind::CHANGE_EPOCH_FIELD.name);
11118 ChangeEpochFieldPathBuilder::new_with_base(self.path)
11119 }
11120 pub fn genesis(mut self) -> GenesisTransactionFieldPathBuilder {
11121 self.path.push(TransactionKind::GENESIS_FIELD.name);
11122 GenesisTransactionFieldPathBuilder::new_with_base(self.path)
11123 }
11124 pub fn consensus_commit_prologue(
11125 mut self,
11126 ) -> ConsensusCommitPrologueFieldPathBuilder {
11127 self.path.push(TransactionKind::CONSENSUS_COMMIT_PROLOGUE_FIELD.name);
11128 ConsensusCommitPrologueFieldPathBuilder::new_with_base(self.path)
11129 }
11130 pub fn authenticator_state_update(
11131 mut self,
11132 ) -> AuthenticatorStateUpdateFieldPathBuilder {
11133 self.path.push(TransactionKind::AUTHENTICATOR_STATE_UPDATE_FIELD.name);
11134 AuthenticatorStateUpdateFieldPathBuilder::new_with_base(self.path)
11135 }
11136 pub fn end_of_epoch(mut self) -> EndOfEpochTransactionFieldPathBuilder {
11137 self.path.push(TransactionKind::END_OF_EPOCH_FIELD.name);
11138 EndOfEpochTransactionFieldPathBuilder::new_with_base(self.path)
11139 }
11140 pub fn randomness_state_update(
11141 mut self,
11142 ) -> RandomnessStateUpdateFieldPathBuilder {
11143 self.path.push(TransactionKind::RANDOMNESS_STATE_UPDATE_FIELD.name);
11144 RandomnessStateUpdateFieldPathBuilder::new_with_base(self.path)
11145 }
11146 }
11147 impl ProgrammableTransaction {
11148 pub const INPUTS_FIELD: &'static MessageField = &MessageField {
11149 name: "inputs",
11150 json_name: "inputs",
11151 number: 1i32,
11152 message_fields: Some(Input::FIELDS),
11153 };
11154 pub const COMMANDS_FIELD: &'static MessageField = &MessageField {
11155 name: "commands",
11156 json_name: "commands",
11157 number: 2i32,
11158 message_fields: Some(Command::FIELDS),
11159 };
11160 }
11161 impl MessageFields for ProgrammableTransaction {
11162 const FIELDS: &'static [&'static MessageField] = &[
11163 Self::INPUTS_FIELD,
11164 Self::COMMANDS_FIELD,
11165 ];
11166 }
11167 impl ProgrammableTransaction {
11168 pub fn path_builder() -> ProgrammableTransactionFieldPathBuilder {
11169 ProgrammableTransactionFieldPathBuilder::new()
11170 }
11171 }
11172 pub struct ProgrammableTransactionFieldPathBuilder {
11173 path: Vec<&'static str>,
11174 }
11175 impl ProgrammableTransactionFieldPathBuilder {
11176 #[allow(clippy::new_without_default)]
11177 pub fn new() -> Self {
11178 Self { path: Default::default() }
11179 }
11180 #[doc(hidden)]
11181 pub fn new_with_base(base: Vec<&'static str>) -> Self {
11182 Self { path: base }
11183 }
11184 pub fn finish(self) -> String {
11185 self.path.join(".")
11186 }
11187 pub fn inputs(mut self) -> InputFieldPathBuilder {
11188 self.path.push(ProgrammableTransaction::INPUTS_FIELD.name);
11189 InputFieldPathBuilder::new_with_base(self.path)
11190 }
11191 pub fn commands(mut self) -> CommandFieldPathBuilder {
11192 self.path.push(ProgrammableTransaction::COMMANDS_FIELD.name);
11193 CommandFieldPathBuilder::new_with_base(self.path)
11194 }
11195 }
11196 impl Command {
11197 pub const MOVE_CALL_FIELD: &'static MessageField = &MessageField {
11198 name: "move_call",
11199 json_name: "moveCall",
11200 number: 1i32,
11201 message_fields: Some(MoveCall::FIELDS),
11202 };
11203 pub const TRANSFER_OBJECTS_FIELD: &'static MessageField = &MessageField {
11204 name: "transfer_objects",
11205 json_name: "transferObjects",
11206 number: 2i32,
11207 message_fields: Some(TransferObjects::FIELDS),
11208 };
11209 pub const SPLIT_COINS_FIELD: &'static MessageField = &MessageField {
11210 name: "split_coins",
11211 json_name: "splitCoins",
11212 number: 3i32,
11213 message_fields: Some(SplitCoins::FIELDS),
11214 };
11215 pub const MERGE_COINS_FIELD: &'static MessageField = &MessageField {
11216 name: "merge_coins",
11217 json_name: "mergeCoins",
11218 number: 4i32,
11219 message_fields: Some(MergeCoins::FIELDS),
11220 };
11221 pub const PUBLISH_FIELD: &'static MessageField = &MessageField {
11222 name: "publish",
11223 json_name: "publish",
11224 number: 5i32,
11225 message_fields: Some(Publish::FIELDS),
11226 };
11227 pub const MAKE_MOVE_VECTOR_FIELD: &'static MessageField = &MessageField {
11228 name: "make_move_vector",
11229 json_name: "makeMoveVector",
11230 number: 6i32,
11231 message_fields: Some(MakeMoveVector::FIELDS),
11232 };
11233 pub const UPGRADE_FIELD: &'static MessageField = &MessageField {
11234 name: "upgrade",
11235 json_name: "upgrade",
11236 number: 7i32,
11237 message_fields: Some(Upgrade::FIELDS),
11238 };
11239 }
11240 impl MessageFields for Command {
11241 const FIELDS: &'static [&'static MessageField] = &[
11242 Self::MOVE_CALL_FIELD,
11243 Self::TRANSFER_OBJECTS_FIELD,
11244 Self::SPLIT_COINS_FIELD,
11245 Self::MERGE_COINS_FIELD,
11246 Self::PUBLISH_FIELD,
11247 Self::MAKE_MOVE_VECTOR_FIELD,
11248 Self::UPGRADE_FIELD,
11249 ];
11250 }
11251 impl Command {
11252 pub fn path_builder() -> CommandFieldPathBuilder {
11253 CommandFieldPathBuilder::new()
11254 }
11255 }
11256 pub struct CommandFieldPathBuilder {
11257 path: Vec<&'static str>,
11258 }
11259 impl CommandFieldPathBuilder {
11260 #[allow(clippy::new_without_default)]
11261 pub fn new() -> Self {
11262 Self { path: Default::default() }
11263 }
11264 #[doc(hidden)]
11265 pub fn new_with_base(base: Vec<&'static str>) -> Self {
11266 Self { path: base }
11267 }
11268 pub fn finish(self) -> String {
11269 self.path.join(".")
11270 }
11271 pub fn move_call(mut self) -> MoveCallFieldPathBuilder {
11272 self.path.push(Command::MOVE_CALL_FIELD.name);
11273 MoveCallFieldPathBuilder::new_with_base(self.path)
11274 }
11275 pub fn transfer_objects(mut self) -> TransferObjectsFieldPathBuilder {
11276 self.path.push(Command::TRANSFER_OBJECTS_FIELD.name);
11277 TransferObjectsFieldPathBuilder::new_with_base(self.path)
11278 }
11279 pub fn split_coins(mut self) -> SplitCoinsFieldPathBuilder {
11280 self.path.push(Command::SPLIT_COINS_FIELD.name);
11281 SplitCoinsFieldPathBuilder::new_with_base(self.path)
11282 }
11283 pub fn merge_coins(mut self) -> MergeCoinsFieldPathBuilder {
11284 self.path.push(Command::MERGE_COINS_FIELD.name);
11285 MergeCoinsFieldPathBuilder::new_with_base(self.path)
11286 }
11287 pub fn publish(mut self) -> PublishFieldPathBuilder {
11288 self.path.push(Command::PUBLISH_FIELD.name);
11289 PublishFieldPathBuilder::new_with_base(self.path)
11290 }
11291 pub fn make_move_vector(mut self) -> MakeMoveVectorFieldPathBuilder {
11292 self.path.push(Command::MAKE_MOVE_VECTOR_FIELD.name);
11293 MakeMoveVectorFieldPathBuilder::new_with_base(self.path)
11294 }
11295 pub fn upgrade(mut self) -> UpgradeFieldPathBuilder {
11296 self.path.push(Command::UPGRADE_FIELD.name);
11297 UpgradeFieldPathBuilder::new_with_base(self.path)
11298 }
11299 }
11300 impl MoveCall {
11301 pub const PACKAGE_FIELD: &'static MessageField = &MessageField {
11302 name: "package",
11303 json_name: "package",
11304 number: 1i32,
11305 message_fields: None,
11306 };
11307 pub const MODULE_FIELD: &'static MessageField = &MessageField {
11308 name: "module",
11309 json_name: "module",
11310 number: 2i32,
11311 message_fields: None,
11312 };
11313 pub const FUNCTION_FIELD: &'static MessageField = &MessageField {
11314 name: "function",
11315 json_name: "function",
11316 number: 3i32,
11317 message_fields: None,
11318 };
11319 pub const TYPE_ARGUMENTS_FIELD: &'static MessageField = &MessageField {
11320 name: "type_arguments",
11321 json_name: "typeArguments",
11322 number: 4i32,
11323 message_fields: None,
11324 };
11325 pub const ARGUMENTS_FIELD: &'static MessageField = &MessageField {
11326 name: "arguments",
11327 json_name: "arguments",
11328 number: 5i32,
11329 message_fields: Some(Argument::FIELDS),
11330 };
11331 }
11332 impl MessageFields for MoveCall {
11333 const FIELDS: &'static [&'static MessageField] = &[
11334 Self::PACKAGE_FIELD,
11335 Self::MODULE_FIELD,
11336 Self::FUNCTION_FIELD,
11337 Self::TYPE_ARGUMENTS_FIELD,
11338 Self::ARGUMENTS_FIELD,
11339 ];
11340 }
11341 impl MoveCall {
11342 pub fn path_builder() -> MoveCallFieldPathBuilder {
11343 MoveCallFieldPathBuilder::new()
11344 }
11345 }
11346 pub struct MoveCallFieldPathBuilder {
11347 path: Vec<&'static str>,
11348 }
11349 impl MoveCallFieldPathBuilder {
11350 #[allow(clippy::new_without_default)]
11351 pub fn new() -> Self {
11352 Self { path: Default::default() }
11353 }
11354 #[doc(hidden)]
11355 pub fn new_with_base(base: Vec<&'static str>) -> Self {
11356 Self { path: base }
11357 }
11358 pub fn finish(self) -> String {
11359 self.path.join(".")
11360 }
11361 pub fn package(mut self) -> String {
11362 self.path.push(MoveCall::PACKAGE_FIELD.name);
11363 self.finish()
11364 }
11365 pub fn module(mut self) -> String {
11366 self.path.push(MoveCall::MODULE_FIELD.name);
11367 self.finish()
11368 }
11369 pub fn function(mut self) -> String {
11370 self.path.push(MoveCall::FUNCTION_FIELD.name);
11371 self.finish()
11372 }
11373 pub fn type_arguments(mut self) -> String {
11374 self.path.push(MoveCall::TYPE_ARGUMENTS_FIELD.name);
11375 self.finish()
11376 }
11377 pub fn arguments(mut self) -> ArgumentFieldPathBuilder {
11378 self.path.push(MoveCall::ARGUMENTS_FIELD.name);
11379 ArgumentFieldPathBuilder::new_with_base(self.path)
11380 }
11381 }
11382 impl TransferObjects {
11383 pub const OBJECTS_FIELD: &'static MessageField = &MessageField {
11384 name: "objects",
11385 json_name: "objects",
11386 number: 1i32,
11387 message_fields: Some(Argument::FIELDS),
11388 };
11389 pub const ADDRESS_FIELD: &'static MessageField = &MessageField {
11390 name: "address",
11391 json_name: "address",
11392 number: 2i32,
11393 message_fields: Some(Argument::FIELDS),
11394 };
11395 }
11396 impl MessageFields for TransferObjects {
11397 const FIELDS: &'static [&'static MessageField] = &[
11398 Self::OBJECTS_FIELD,
11399 Self::ADDRESS_FIELD,
11400 ];
11401 }
11402 impl TransferObjects {
11403 pub fn path_builder() -> TransferObjectsFieldPathBuilder {
11404 TransferObjectsFieldPathBuilder::new()
11405 }
11406 }
11407 pub struct TransferObjectsFieldPathBuilder {
11408 path: Vec<&'static str>,
11409 }
11410 impl TransferObjectsFieldPathBuilder {
11411 #[allow(clippy::new_without_default)]
11412 pub fn new() -> Self {
11413 Self { path: Default::default() }
11414 }
11415 #[doc(hidden)]
11416 pub fn new_with_base(base: Vec<&'static str>) -> Self {
11417 Self { path: base }
11418 }
11419 pub fn finish(self) -> String {
11420 self.path.join(".")
11421 }
11422 pub fn objects(mut self) -> ArgumentFieldPathBuilder {
11423 self.path.push(TransferObjects::OBJECTS_FIELD.name);
11424 ArgumentFieldPathBuilder::new_with_base(self.path)
11425 }
11426 pub fn address(mut self) -> ArgumentFieldPathBuilder {
11427 self.path.push(TransferObjects::ADDRESS_FIELD.name);
11428 ArgumentFieldPathBuilder::new_with_base(self.path)
11429 }
11430 }
11431 impl SplitCoins {
11432 pub const COIN_FIELD: &'static MessageField = &MessageField {
11433 name: "coin",
11434 json_name: "coin",
11435 number: 1i32,
11436 message_fields: Some(Argument::FIELDS),
11437 };
11438 pub const AMOUNTS_FIELD: &'static MessageField = &MessageField {
11439 name: "amounts",
11440 json_name: "amounts",
11441 number: 2i32,
11442 message_fields: Some(Argument::FIELDS),
11443 };
11444 }
11445 impl MessageFields for SplitCoins {
11446 const FIELDS: &'static [&'static MessageField] = &[
11447 Self::COIN_FIELD,
11448 Self::AMOUNTS_FIELD,
11449 ];
11450 }
11451 impl SplitCoins {
11452 pub fn path_builder() -> SplitCoinsFieldPathBuilder {
11453 SplitCoinsFieldPathBuilder::new()
11454 }
11455 }
11456 pub struct SplitCoinsFieldPathBuilder {
11457 path: Vec<&'static str>,
11458 }
11459 impl SplitCoinsFieldPathBuilder {
11460 #[allow(clippy::new_without_default)]
11461 pub fn new() -> Self {
11462 Self { path: Default::default() }
11463 }
11464 #[doc(hidden)]
11465 pub fn new_with_base(base: Vec<&'static str>) -> Self {
11466 Self { path: base }
11467 }
11468 pub fn finish(self) -> String {
11469 self.path.join(".")
11470 }
11471 pub fn coin(mut self) -> ArgumentFieldPathBuilder {
11472 self.path.push(SplitCoins::COIN_FIELD.name);
11473 ArgumentFieldPathBuilder::new_with_base(self.path)
11474 }
11475 pub fn amounts(mut self) -> ArgumentFieldPathBuilder {
11476 self.path.push(SplitCoins::AMOUNTS_FIELD.name);
11477 ArgumentFieldPathBuilder::new_with_base(self.path)
11478 }
11479 }
11480 impl MergeCoins {
11481 pub const COIN_FIELD: &'static MessageField = &MessageField {
11482 name: "coin",
11483 json_name: "coin",
11484 number: 1i32,
11485 message_fields: Some(Argument::FIELDS),
11486 };
11487 pub const COINS_TO_MERGE_FIELD: &'static MessageField = &MessageField {
11488 name: "coins_to_merge",
11489 json_name: "coinsToMerge",
11490 number: 2i32,
11491 message_fields: Some(Argument::FIELDS),
11492 };
11493 }
11494 impl MessageFields for MergeCoins {
11495 const FIELDS: &'static [&'static MessageField] = &[
11496 Self::COIN_FIELD,
11497 Self::COINS_TO_MERGE_FIELD,
11498 ];
11499 }
11500 impl MergeCoins {
11501 pub fn path_builder() -> MergeCoinsFieldPathBuilder {
11502 MergeCoinsFieldPathBuilder::new()
11503 }
11504 }
11505 pub struct MergeCoinsFieldPathBuilder {
11506 path: Vec<&'static str>,
11507 }
11508 impl MergeCoinsFieldPathBuilder {
11509 #[allow(clippy::new_without_default)]
11510 pub fn new() -> Self {
11511 Self { path: Default::default() }
11512 }
11513 #[doc(hidden)]
11514 pub fn new_with_base(base: Vec<&'static str>) -> Self {
11515 Self { path: base }
11516 }
11517 pub fn finish(self) -> String {
11518 self.path.join(".")
11519 }
11520 pub fn coin(mut self) -> ArgumentFieldPathBuilder {
11521 self.path.push(MergeCoins::COIN_FIELD.name);
11522 ArgumentFieldPathBuilder::new_with_base(self.path)
11523 }
11524 pub fn coins_to_merge(mut self) -> ArgumentFieldPathBuilder {
11525 self.path.push(MergeCoins::COINS_TO_MERGE_FIELD.name);
11526 ArgumentFieldPathBuilder::new_with_base(self.path)
11527 }
11528 }
11529 impl Publish {
11530 pub const MODULES_FIELD: &'static MessageField = &MessageField {
11531 name: "modules",
11532 json_name: "modules",
11533 number: 1i32,
11534 message_fields: None,
11535 };
11536 pub const DEPENDENCIES_FIELD: &'static MessageField = &MessageField {
11537 name: "dependencies",
11538 json_name: "dependencies",
11539 number: 2i32,
11540 message_fields: None,
11541 };
11542 }
11543 impl MessageFields for Publish {
11544 const FIELDS: &'static [&'static MessageField] = &[
11545 Self::MODULES_FIELD,
11546 Self::DEPENDENCIES_FIELD,
11547 ];
11548 }
11549 impl Publish {
11550 pub fn path_builder() -> PublishFieldPathBuilder {
11551 PublishFieldPathBuilder::new()
11552 }
11553 }
11554 pub struct PublishFieldPathBuilder {
11555 path: Vec<&'static str>,
11556 }
11557 impl PublishFieldPathBuilder {
11558 #[allow(clippy::new_without_default)]
11559 pub fn new() -> Self {
11560 Self { path: Default::default() }
11561 }
11562 #[doc(hidden)]
11563 pub fn new_with_base(base: Vec<&'static str>) -> Self {
11564 Self { path: base }
11565 }
11566 pub fn finish(self) -> String {
11567 self.path.join(".")
11568 }
11569 pub fn modules(mut self) -> String {
11570 self.path.push(Publish::MODULES_FIELD.name);
11571 self.finish()
11572 }
11573 pub fn dependencies(mut self) -> String {
11574 self.path.push(Publish::DEPENDENCIES_FIELD.name);
11575 self.finish()
11576 }
11577 }
11578 impl MakeMoveVector {
11579 pub const ELEMENT_TYPE_FIELD: &'static MessageField = &MessageField {
11580 name: "element_type",
11581 json_name: "elementType",
11582 number: 1i32,
11583 message_fields: None,
11584 };
11585 pub const ELEMENTS_FIELD: &'static MessageField = &MessageField {
11586 name: "elements",
11587 json_name: "elements",
11588 number: 2i32,
11589 message_fields: Some(Argument::FIELDS),
11590 };
11591 }
11592 impl MessageFields for MakeMoveVector {
11593 const FIELDS: &'static [&'static MessageField] = &[
11594 Self::ELEMENT_TYPE_FIELD,
11595 Self::ELEMENTS_FIELD,
11596 ];
11597 }
11598 impl MakeMoveVector {
11599 pub fn path_builder() -> MakeMoveVectorFieldPathBuilder {
11600 MakeMoveVectorFieldPathBuilder::new()
11601 }
11602 }
11603 pub struct MakeMoveVectorFieldPathBuilder {
11604 path: Vec<&'static str>,
11605 }
11606 impl MakeMoveVectorFieldPathBuilder {
11607 #[allow(clippy::new_without_default)]
11608 pub fn new() -> Self {
11609 Self { path: Default::default() }
11610 }
11611 #[doc(hidden)]
11612 pub fn new_with_base(base: Vec<&'static str>) -> Self {
11613 Self { path: base }
11614 }
11615 pub fn finish(self) -> String {
11616 self.path.join(".")
11617 }
11618 pub fn element_type(mut self) -> String {
11619 self.path.push(MakeMoveVector::ELEMENT_TYPE_FIELD.name);
11620 self.finish()
11621 }
11622 pub fn elements(mut self) -> ArgumentFieldPathBuilder {
11623 self.path.push(MakeMoveVector::ELEMENTS_FIELD.name);
11624 ArgumentFieldPathBuilder::new_with_base(self.path)
11625 }
11626 }
11627 impl Upgrade {
11628 pub const MODULES_FIELD: &'static MessageField = &MessageField {
11629 name: "modules",
11630 json_name: "modules",
11631 number: 1i32,
11632 message_fields: None,
11633 };
11634 pub const DEPENDENCIES_FIELD: &'static MessageField = &MessageField {
11635 name: "dependencies",
11636 json_name: "dependencies",
11637 number: 2i32,
11638 message_fields: None,
11639 };
11640 pub const PACKAGE_FIELD: &'static MessageField = &MessageField {
11641 name: "package",
11642 json_name: "package",
11643 number: 3i32,
11644 message_fields: None,
11645 };
11646 pub const TICKET_FIELD: &'static MessageField = &MessageField {
11647 name: "ticket",
11648 json_name: "ticket",
11649 number: 4i32,
11650 message_fields: Some(Argument::FIELDS),
11651 };
11652 }
11653 impl MessageFields for Upgrade {
11654 const FIELDS: &'static [&'static MessageField] = &[
11655 Self::MODULES_FIELD,
11656 Self::DEPENDENCIES_FIELD,
11657 Self::PACKAGE_FIELD,
11658 Self::TICKET_FIELD,
11659 ];
11660 }
11661 impl Upgrade {
11662 pub fn path_builder() -> UpgradeFieldPathBuilder {
11663 UpgradeFieldPathBuilder::new()
11664 }
11665 }
11666 pub struct UpgradeFieldPathBuilder {
11667 path: Vec<&'static str>,
11668 }
11669 impl UpgradeFieldPathBuilder {
11670 #[allow(clippy::new_without_default)]
11671 pub fn new() -> Self {
11672 Self { path: Default::default() }
11673 }
11674 #[doc(hidden)]
11675 pub fn new_with_base(base: Vec<&'static str>) -> Self {
11676 Self { path: base }
11677 }
11678 pub fn finish(self) -> String {
11679 self.path.join(".")
11680 }
11681 pub fn modules(mut self) -> String {
11682 self.path.push(Upgrade::MODULES_FIELD.name);
11683 self.finish()
11684 }
11685 pub fn dependencies(mut self) -> String {
11686 self.path.push(Upgrade::DEPENDENCIES_FIELD.name);
11687 self.finish()
11688 }
11689 pub fn package(mut self) -> String {
11690 self.path.push(Upgrade::PACKAGE_FIELD.name);
11691 self.finish()
11692 }
11693 pub fn ticket(mut self) -> ArgumentFieldPathBuilder {
11694 self.path.push(Upgrade::TICKET_FIELD.name);
11695 ArgumentFieldPathBuilder::new_with_base(self.path)
11696 }
11697 }
11698 impl RandomnessStateUpdate {
11699 pub const EPOCH_FIELD: &'static MessageField = &MessageField {
11700 name: "epoch",
11701 json_name: "epoch",
11702 number: 1i32,
11703 message_fields: None,
11704 };
11705 pub const RANDOMNESS_ROUND_FIELD: &'static MessageField = &MessageField {
11706 name: "randomness_round",
11707 json_name: "randomnessRound",
11708 number: 2i32,
11709 message_fields: None,
11710 };
11711 pub const RANDOM_BYTES_FIELD: &'static MessageField = &MessageField {
11712 name: "random_bytes",
11713 json_name: "randomBytes",
11714 number: 3i32,
11715 message_fields: None,
11716 };
11717 pub const RANDOMNESS_OBJECT_INITIAL_SHARED_VERSION_FIELD: &'static MessageField = &MessageField {
11718 name: "randomness_object_initial_shared_version",
11719 json_name: "randomnessObjectInitialSharedVersion",
11720 number: 4i32,
11721 message_fields: None,
11722 };
11723 }
11724 impl MessageFields for RandomnessStateUpdate {
11725 const FIELDS: &'static [&'static MessageField] = &[
11726 Self::EPOCH_FIELD,
11727 Self::RANDOMNESS_ROUND_FIELD,
11728 Self::RANDOM_BYTES_FIELD,
11729 Self::RANDOMNESS_OBJECT_INITIAL_SHARED_VERSION_FIELD,
11730 ];
11731 }
11732 impl RandomnessStateUpdate {
11733 pub fn path_builder() -> RandomnessStateUpdateFieldPathBuilder {
11734 RandomnessStateUpdateFieldPathBuilder::new()
11735 }
11736 }
11737 pub struct RandomnessStateUpdateFieldPathBuilder {
11738 path: Vec<&'static str>,
11739 }
11740 impl RandomnessStateUpdateFieldPathBuilder {
11741 #[allow(clippy::new_without_default)]
11742 pub fn new() -> Self {
11743 Self { path: Default::default() }
11744 }
11745 #[doc(hidden)]
11746 pub fn new_with_base(base: Vec<&'static str>) -> Self {
11747 Self { path: base }
11748 }
11749 pub fn finish(self) -> String {
11750 self.path.join(".")
11751 }
11752 pub fn epoch(mut self) -> String {
11753 self.path.push(RandomnessStateUpdate::EPOCH_FIELD.name);
11754 self.finish()
11755 }
11756 pub fn randomness_round(mut self) -> String {
11757 self.path.push(RandomnessStateUpdate::RANDOMNESS_ROUND_FIELD.name);
11758 self.finish()
11759 }
11760 pub fn random_bytes(mut self) -> String {
11761 self.path.push(RandomnessStateUpdate::RANDOM_BYTES_FIELD.name);
11762 self.finish()
11763 }
11764 pub fn randomness_object_initial_shared_version(mut self) -> String {
11765 self.path
11766 .push(
11767 RandomnessStateUpdate::RANDOMNESS_OBJECT_INITIAL_SHARED_VERSION_FIELD
11768 .name,
11769 );
11770 self.finish()
11771 }
11772 }
11773 impl ChangeEpoch {
11774 pub const EPOCH_FIELD: &'static MessageField = &MessageField {
11775 name: "epoch",
11776 json_name: "epoch",
11777 number: 1i32,
11778 message_fields: None,
11779 };
11780 pub const PROTOCOL_VERSION_FIELD: &'static MessageField = &MessageField {
11781 name: "protocol_version",
11782 json_name: "protocolVersion",
11783 number: 2i32,
11784 message_fields: None,
11785 };
11786 pub const STORAGE_CHARGE_FIELD: &'static MessageField = &MessageField {
11787 name: "storage_charge",
11788 json_name: "storageCharge",
11789 number: 3i32,
11790 message_fields: None,
11791 };
11792 pub const COMPUTATION_CHARGE_FIELD: &'static MessageField = &MessageField {
11793 name: "computation_charge",
11794 json_name: "computationCharge",
11795 number: 4i32,
11796 message_fields: None,
11797 };
11798 pub const STORAGE_REBATE_FIELD: &'static MessageField = &MessageField {
11799 name: "storage_rebate",
11800 json_name: "storageRebate",
11801 number: 5i32,
11802 message_fields: None,
11803 };
11804 pub const NON_REFUNDABLE_STORAGE_FEE_FIELD: &'static MessageField = &MessageField {
11805 name: "non_refundable_storage_fee",
11806 json_name: "nonRefundableStorageFee",
11807 number: 6i32,
11808 message_fields: None,
11809 };
11810 pub const EPOCH_START_TIMESTAMP_FIELD: &'static MessageField = &MessageField {
11811 name: "epoch_start_timestamp",
11812 json_name: "epochStartTimestamp",
11813 number: 7i32,
11814 message_fields: None,
11815 };
11816 pub const SYSTEM_PACKAGES_FIELD: &'static MessageField = &MessageField {
11817 name: "system_packages",
11818 json_name: "systemPackages",
11819 number: 8i32,
11820 message_fields: Some(SystemPackage::FIELDS),
11821 };
11822 }
11823 impl MessageFields for ChangeEpoch {
11824 const FIELDS: &'static [&'static MessageField] = &[
11825 Self::EPOCH_FIELD,
11826 Self::PROTOCOL_VERSION_FIELD,
11827 Self::STORAGE_CHARGE_FIELD,
11828 Self::COMPUTATION_CHARGE_FIELD,
11829 Self::STORAGE_REBATE_FIELD,
11830 Self::NON_REFUNDABLE_STORAGE_FEE_FIELD,
11831 Self::EPOCH_START_TIMESTAMP_FIELD,
11832 Self::SYSTEM_PACKAGES_FIELD,
11833 ];
11834 }
11835 impl ChangeEpoch {
11836 pub fn path_builder() -> ChangeEpochFieldPathBuilder {
11837 ChangeEpochFieldPathBuilder::new()
11838 }
11839 }
11840 pub struct ChangeEpochFieldPathBuilder {
11841 path: Vec<&'static str>,
11842 }
11843 impl ChangeEpochFieldPathBuilder {
11844 #[allow(clippy::new_without_default)]
11845 pub fn new() -> Self {
11846 Self { path: Default::default() }
11847 }
11848 #[doc(hidden)]
11849 pub fn new_with_base(base: Vec<&'static str>) -> Self {
11850 Self { path: base }
11851 }
11852 pub fn finish(self) -> String {
11853 self.path.join(".")
11854 }
11855 pub fn epoch(mut self) -> String {
11856 self.path.push(ChangeEpoch::EPOCH_FIELD.name);
11857 self.finish()
11858 }
11859 pub fn protocol_version(mut self) -> String {
11860 self.path.push(ChangeEpoch::PROTOCOL_VERSION_FIELD.name);
11861 self.finish()
11862 }
11863 pub fn storage_charge(mut self) -> String {
11864 self.path.push(ChangeEpoch::STORAGE_CHARGE_FIELD.name);
11865 self.finish()
11866 }
11867 pub fn computation_charge(mut self) -> String {
11868 self.path.push(ChangeEpoch::COMPUTATION_CHARGE_FIELD.name);
11869 self.finish()
11870 }
11871 pub fn storage_rebate(mut self) -> String {
11872 self.path.push(ChangeEpoch::STORAGE_REBATE_FIELD.name);
11873 self.finish()
11874 }
11875 pub fn non_refundable_storage_fee(mut self) -> String {
11876 self.path.push(ChangeEpoch::NON_REFUNDABLE_STORAGE_FEE_FIELD.name);
11877 self.finish()
11878 }
11879 pub fn epoch_start_timestamp(mut self) -> String {
11880 self.path.push(ChangeEpoch::EPOCH_START_TIMESTAMP_FIELD.name);
11881 self.finish()
11882 }
11883 pub fn system_packages(mut self) -> SystemPackageFieldPathBuilder {
11884 self.path.push(ChangeEpoch::SYSTEM_PACKAGES_FIELD.name);
11885 SystemPackageFieldPathBuilder::new_with_base(self.path)
11886 }
11887 }
11888 impl SystemPackage {
11889 pub const VERSION_FIELD: &'static MessageField = &MessageField {
11890 name: "version",
11891 json_name: "version",
11892 number: 1i32,
11893 message_fields: None,
11894 };
11895 pub const MODULES_FIELD: &'static MessageField = &MessageField {
11896 name: "modules",
11897 json_name: "modules",
11898 number: 2i32,
11899 message_fields: None,
11900 };
11901 pub const DEPENDENCIES_FIELD: &'static MessageField = &MessageField {
11902 name: "dependencies",
11903 json_name: "dependencies",
11904 number: 3i32,
11905 message_fields: None,
11906 };
11907 }
11908 impl MessageFields for SystemPackage {
11909 const FIELDS: &'static [&'static MessageField] = &[
11910 Self::VERSION_FIELD,
11911 Self::MODULES_FIELD,
11912 Self::DEPENDENCIES_FIELD,
11913 ];
11914 }
11915 impl SystemPackage {
11916 pub fn path_builder() -> SystemPackageFieldPathBuilder {
11917 SystemPackageFieldPathBuilder::new()
11918 }
11919 }
11920 pub struct SystemPackageFieldPathBuilder {
11921 path: Vec<&'static str>,
11922 }
11923 impl SystemPackageFieldPathBuilder {
11924 #[allow(clippy::new_without_default)]
11925 pub fn new() -> Self {
11926 Self { path: Default::default() }
11927 }
11928 #[doc(hidden)]
11929 pub fn new_with_base(base: Vec<&'static str>) -> Self {
11930 Self { path: base }
11931 }
11932 pub fn finish(self) -> String {
11933 self.path.join(".")
11934 }
11935 pub fn version(mut self) -> String {
11936 self.path.push(SystemPackage::VERSION_FIELD.name);
11937 self.finish()
11938 }
11939 pub fn modules(mut self) -> String {
11940 self.path.push(SystemPackage::MODULES_FIELD.name);
11941 self.finish()
11942 }
11943 pub fn dependencies(mut self) -> String {
11944 self.path.push(SystemPackage::DEPENDENCIES_FIELD.name);
11945 self.finish()
11946 }
11947 }
11948 impl GenesisTransaction {
11949 pub const OBJECTS_FIELD: &'static MessageField = &MessageField {
11950 name: "objects",
11951 json_name: "objects",
11952 number: 1i32,
11953 message_fields: Some(Object::FIELDS),
11954 };
11955 }
11956 impl MessageFields for GenesisTransaction {
11957 const FIELDS: &'static [&'static MessageField] = &[Self::OBJECTS_FIELD];
11958 }
11959 impl GenesisTransaction {
11960 pub fn path_builder() -> GenesisTransactionFieldPathBuilder {
11961 GenesisTransactionFieldPathBuilder::new()
11962 }
11963 }
11964 pub struct GenesisTransactionFieldPathBuilder {
11965 path: Vec<&'static str>,
11966 }
11967 impl GenesisTransactionFieldPathBuilder {
11968 #[allow(clippy::new_without_default)]
11969 pub fn new() -> Self {
11970 Self { path: Default::default() }
11971 }
11972 #[doc(hidden)]
11973 pub fn new_with_base(base: Vec<&'static str>) -> Self {
11974 Self { path: base }
11975 }
11976 pub fn finish(self) -> String {
11977 self.path.join(".")
11978 }
11979 pub fn objects(mut self) -> ObjectFieldPathBuilder {
11980 self.path.push(GenesisTransaction::OBJECTS_FIELD.name);
11981 ObjectFieldPathBuilder::new_with_base(self.path)
11982 }
11983 }
11984 impl ConsensusCommitPrologue {
11985 pub const EPOCH_FIELD: &'static MessageField = &MessageField {
11986 name: "epoch",
11987 json_name: "epoch",
11988 number: 1i32,
11989 message_fields: None,
11990 };
11991 pub const ROUND_FIELD: &'static MessageField = &MessageField {
11992 name: "round",
11993 json_name: "round",
11994 number: 2i32,
11995 message_fields: None,
11996 };
11997 pub const COMMIT_TIMESTAMP_FIELD: &'static MessageField = &MessageField {
11998 name: "commit_timestamp",
11999 json_name: "commitTimestamp",
12000 number: 3i32,
12001 message_fields: None,
12002 };
12003 pub const CONSENSUS_COMMIT_DIGEST_FIELD: &'static MessageField = &MessageField {
12004 name: "consensus_commit_digest",
12005 json_name: "consensusCommitDigest",
12006 number: 4i32,
12007 message_fields: None,
12008 };
12009 pub const SUB_DAG_INDEX_FIELD: &'static MessageField = &MessageField {
12010 name: "sub_dag_index",
12011 json_name: "subDagIndex",
12012 number: 5i32,
12013 message_fields: None,
12014 };
12015 pub const CONSENSUS_DETERMINED_VERSION_ASSIGNMENTS_FIELD: &'static MessageField = &MessageField {
12016 name: "consensus_determined_version_assignments",
12017 json_name: "consensusDeterminedVersionAssignments",
12018 number: 6i32,
12019 message_fields: Some(ConsensusDeterminedVersionAssignments::FIELDS),
12020 };
12021 pub const ADDITIONAL_STATE_DIGEST_FIELD: &'static MessageField = &MessageField {
12022 name: "additional_state_digest",
12023 json_name: "additionalStateDigest",
12024 number: 7i32,
12025 message_fields: None,
12026 };
12027 }
12028 impl MessageFields for ConsensusCommitPrologue {
12029 const FIELDS: &'static [&'static MessageField] = &[
12030 Self::EPOCH_FIELD,
12031 Self::ROUND_FIELD,
12032 Self::COMMIT_TIMESTAMP_FIELD,
12033 Self::CONSENSUS_COMMIT_DIGEST_FIELD,
12034 Self::SUB_DAG_INDEX_FIELD,
12035 Self::CONSENSUS_DETERMINED_VERSION_ASSIGNMENTS_FIELD,
12036 Self::ADDITIONAL_STATE_DIGEST_FIELD,
12037 ];
12038 }
12039 impl ConsensusCommitPrologue {
12040 pub fn path_builder() -> ConsensusCommitPrologueFieldPathBuilder {
12041 ConsensusCommitPrologueFieldPathBuilder::new()
12042 }
12043 }
12044 pub struct ConsensusCommitPrologueFieldPathBuilder {
12045 path: Vec<&'static str>,
12046 }
12047 impl ConsensusCommitPrologueFieldPathBuilder {
12048 #[allow(clippy::new_without_default)]
12049 pub fn new() -> Self {
12050 Self { path: Default::default() }
12051 }
12052 #[doc(hidden)]
12053 pub fn new_with_base(base: Vec<&'static str>) -> Self {
12054 Self { path: base }
12055 }
12056 pub fn finish(self) -> String {
12057 self.path.join(".")
12058 }
12059 pub fn epoch(mut self) -> String {
12060 self.path.push(ConsensusCommitPrologue::EPOCH_FIELD.name);
12061 self.finish()
12062 }
12063 pub fn round(mut self) -> String {
12064 self.path.push(ConsensusCommitPrologue::ROUND_FIELD.name);
12065 self.finish()
12066 }
12067 pub fn commit_timestamp(mut self) -> String {
12068 self.path.push(ConsensusCommitPrologue::COMMIT_TIMESTAMP_FIELD.name);
12069 self.finish()
12070 }
12071 pub fn consensus_commit_digest(mut self) -> String {
12072 self.path.push(ConsensusCommitPrologue::CONSENSUS_COMMIT_DIGEST_FIELD.name);
12073 self.finish()
12074 }
12075 pub fn sub_dag_index(mut self) -> String {
12076 self.path.push(ConsensusCommitPrologue::SUB_DAG_INDEX_FIELD.name);
12077 self.finish()
12078 }
12079 pub fn consensus_determined_version_assignments(
12080 mut self,
12081 ) -> ConsensusDeterminedVersionAssignmentsFieldPathBuilder {
12082 self.path
12083 .push(
12084 ConsensusCommitPrologue::CONSENSUS_DETERMINED_VERSION_ASSIGNMENTS_FIELD
12085 .name,
12086 );
12087 ConsensusDeterminedVersionAssignmentsFieldPathBuilder::new_with_base(
12088 self.path,
12089 )
12090 }
12091 pub fn additional_state_digest(mut self) -> String {
12092 self.path.push(ConsensusCommitPrologue::ADDITIONAL_STATE_DIGEST_FIELD.name);
12093 self.finish()
12094 }
12095 }
12096 impl VersionAssignment {
12097 pub const OBJECT_ID_FIELD: &'static MessageField = &MessageField {
12098 name: "object_id",
12099 json_name: "objectId",
12100 number: 1i32,
12101 message_fields: None,
12102 };
12103 pub const START_VERSION_FIELD: &'static MessageField = &MessageField {
12104 name: "start_version",
12105 json_name: "startVersion",
12106 number: 2i32,
12107 message_fields: None,
12108 };
12109 pub const VERSION_FIELD: &'static MessageField = &MessageField {
12110 name: "version",
12111 json_name: "version",
12112 number: 3i32,
12113 message_fields: None,
12114 };
12115 }
12116 impl MessageFields for VersionAssignment {
12117 const FIELDS: &'static [&'static MessageField] = &[
12118 Self::OBJECT_ID_FIELD,
12119 Self::START_VERSION_FIELD,
12120 Self::VERSION_FIELD,
12121 ];
12122 }
12123 impl VersionAssignment {
12124 pub fn path_builder() -> VersionAssignmentFieldPathBuilder {
12125 VersionAssignmentFieldPathBuilder::new()
12126 }
12127 }
12128 pub struct VersionAssignmentFieldPathBuilder {
12129 path: Vec<&'static str>,
12130 }
12131 impl VersionAssignmentFieldPathBuilder {
12132 #[allow(clippy::new_without_default)]
12133 pub fn new() -> Self {
12134 Self { path: Default::default() }
12135 }
12136 #[doc(hidden)]
12137 pub fn new_with_base(base: Vec<&'static str>) -> Self {
12138 Self { path: base }
12139 }
12140 pub fn finish(self) -> String {
12141 self.path.join(".")
12142 }
12143 pub fn object_id(mut self) -> String {
12144 self.path.push(VersionAssignment::OBJECT_ID_FIELD.name);
12145 self.finish()
12146 }
12147 pub fn start_version(mut self) -> String {
12148 self.path.push(VersionAssignment::START_VERSION_FIELD.name);
12149 self.finish()
12150 }
12151 pub fn version(mut self) -> String {
12152 self.path.push(VersionAssignment::VERSION_FIELD.name);
12153 self.finish()
12154 }
12155 }
12156 impl CanceledTransaction {
12157 pub const DIGEST_FIELD: &'static MessageField = &MessageField {
12158 name: "digest",
12159 json_name: "digest",
12160 number: 1i32,
12161 message_fields: None,
12162 };
12163 pub const VERSION_ASSIGNMENTS_FIELD: &'static MessageField = &MessageField {
12164 name: "version_assignments",
12165 json_name: "versionAssignments",
12166 number: 2i32,
12167 message_fields: Some(VersionAssignment::FIELDS),
12168 };
12169 }
12170 impl MessageFields for CanceledTransaction {
12171 const FIELDS: &'static [&'static MessageField] = &[
12172 Self::DIGEST_FIELD,
12173 Self::VERSION_ASSIGNMENTS_FIELD,
12174 ];
12175 }
12176 impl CanceledTransaction {
12177 pub fn path_builder() -> CanceledTransactionFieldPathBuilder {
12178 CanceledTransactionFieldPathBuilder::new()
12179 }
12180 }
12181 pub struct CanceledTransactionFieldPathBuilder {
12182 path: Vec<&'static str>,
12183 }
12184 impl CanceledTransactionFieldPathBuilder {
12185 #[allow(clippy::new_without_default)]
12186 pub fn new() -> Self {
12187 Self { path: Default::default() }
12188 }
12189 #[doc(hidden)]
12190 pub fn new_with_base(base: Vec<&'static str>) -> Self {
12191 Self { path: base }
12192 }
12193 pub fn finish(self) -> String {
12194 self.path.join(".")
12195 }
12196 pub fn digest(mut self) -> String {
12197 self.path.push(CanceledTransaction::DIGEST_FIELD.name);
12198 self.finish()
12199 }
12200 pub fn version_assignments(mut self) -> VersionAssignmentFieldPathBuilder {
12201 self.path.push(CanceledTransaction::VERSION_ASSIGNMENTS_FIELD.name);
12202 VersionAssignmentFieldPathBuilder::new_with_base(self.path)
12203 }
12204 }
12205 impl ConsensusDeterminedVersionAssignments {
12206 pub const VERSION_FIELD: &'static MessageField = &MessageField {
12207 name: "version",
12208 json_name: "version",
12209 number: 1i32,
12210 message_fields: None,
12211 };
12212 pub const CANCELED_TRANSACTIONS_FIELD: &'static MessageField = &MessageField {
12213 name: "canceled_transactions",
12214 json_name: "canceledTransactions",
12215 number: 3i32,
12216 message_fields: Some(CanceledTransaction::FIELDS),
12217 };
12218 }
12219 impl MessageFields for ConsensusDeterminedVersionAssignments {
12220 const FIELDS: &'static [&'static MessageField] = &[
12221 Self::VERSION_FIELD,
12222 Self::CANCELED_TRANSACTIONS_FIELD,
12223 ];
12224 }
12225 impl ConsensusDeterminedVersionAssignments {
12226 pub fn path_builder() -> ConsensusDeterminedVersionAssignmentsFieldPathBuilder {
12227 ConsensusDeterminedVersionAssignmentsFieldPathBuilder::new()
12228 }
12229 }
12230 pub struct ConsensusDeterminedVersionAssignmentsFieldPathBuilder {
12231 path: Vec<&'static str>,
12232 }
12233 impl ConsensusDeterminedVersionAssignmentsFieldPathBuilder {
12234 #[allow(clippy::new_without_default)]
12235 pub fn new() -> Self {
12236 Self { path: Default::default() }
12237 }
12238 #[doc(hidden)]
12239 pub fn new_with_base(base: Vec<&'static str>) -> Self {
12240 Self { path: base }
12241 }
12242 pub fn finish(self) -> String {
12243 self.path.join(".")
12244 }
12245 pub fn version(mut self) -> String {
12246 self.path.push(ConsensusDeterminedVersionAssignments::VERSION_FIELD.name);
12247 self.finish()
12248 }
12249 pub fn canceled_transactions(mut self) -> CanceledTransactionFieldPathBuilder {
12250 self.path
12251 .push(
12252 ConsensusDeterminedVersionAssignments::CANCELED_TRANSACTIONS_FIELD
12253 .name,
12254 );
12255 CanceledTransactionFieldPathBuilder::new_with_base(self.path)
12256 }
12257 }
12258 impl AuthenticatorStateUpdate {
12259 pub const EPOCH_FIELD: &'static MessageField = &MessageField {
12260 name: "epoch",
12261 json_name: "epoch",
12262 number: 1i32,
12263 message_fields: None,
12264 };
12265 pub const ROUND_FIELD: &'static MessageField = &MessageField {
12266 name: "round",
12267 json_name: "round",
12268 number: 2i32,
12269 message_fields: None,
12270 };
12271 pub const NEW_ACTIVE_JWKS_FIELD: &'static MessageField = &MessageField {
12272 name: "new_active_jwks",
12273 json_name: "newActiveJwks",
12274 number: 3i32,
12275 message_fields: Some(ActiveJwk::FIELDS),
12276 };
12277 pub const AUTHENTICATOR_OBJECT_INITIAL_SHARED_VERSION_FIELD: &'static MessageField = &MessageField {
12278 name: "authenticator_object_initial_shared_version",
12279 json_name: "authenticatorObjectInitialSharedVersion",
12280 number: 4i32,
12281 message_fields: None,
12282 };
12283 }
12284 impl MessageFields for AuthenticatorStateUpdate {
12285 const FIELDS: &'static [&'static MessageField] = &[
12286 Self::EPOCH_FIELD,
12287 Self::ROUND_FIELD,
12288 Self::NEW_ACTIVE_JWKS_FIELD,
12289 Self::AUTHENTICATOR_OBJECT_INITIAL_SHARED_VERSION_FIELD,
12290 ];
12291 }
12292 impl AuthenticatorStateUpdate {
12293 pub fn path_builder() -> AuthenticatorStateUpdateFieldPathBuilder {
12294 AuthenticatorStateUpdateFieldPathBuilder::new()
12295 }
12296 }
12297 pub struct AuthenticatorStateUpdateFieldPathBuilder {
12298 path: Vec<&'static str>,
12299 }
12300 impl AuthenticatorStateUpdateFieldPathBuilder {
12301 #[allow(clippy::new_without_default)]
12302 pub fn new() -> Self {
12303 Self { path: Default::default() }
12304 }
12305 #[doc(hidden)]
12306 pub fn new_with_base(base: Vec<&'static str>) -> Self {
12307 Self { path: base }
12308 }
12309 pub fn finish(self) -> String {
12310 self.path.join(".")
12311 }
12312 pub fn epoch(mut self) -> String {
12313 self.path.push(AuthenticatorStateUpdate::EPOCH_FIELD.name);
12314 self.finish()
12315 }
12316 pub fn round(mut self) -> String {
12317 self.path.push(AuthenticatorStateUpdate::ROUND_FIELD.name);
12318 self.finish()
12319 }
12320 pub fn new_active_jwks(mut self) -> ActiveJwkFieldPathBuilder {
12321 self.path.push(AuthenticatorStateUpdate::NEW_ACTIVE_JWKS_FIELD.name);
12322 ActiveJwkFieldPathBuilder::new_with_base(self.path)
12323 }
12324 pub fn authenticator_object_initial_shared_version(mut self) -> String {
12325 self.path
12326 .push(
12327 AuthenticatorStateUpdate::AUTHENTICATOR_OBJECT_INITIAL_SHARED_VERSION_FIELD
12328 .name,
12329 );
12330 self.finish()
12331 }
12332 }
12333 impl ActiveJwk {
12334 pub const ID_FIELD: &'static MessageField = &MessageField {
12335 name: "id",
12336 json_name: "id",
12337 number: 1i32,
12338 message_fields: Some(JwkId::FIELDS),
12339 };
12340 pub const JWK_FIELD: &'static MessageField = &MessageField {
12341 name: "jwk",
12342 json_name: "jwk",
12343 number: 2i32,
12344 message_fields: Some(Jwk::FIELDS),
12345 };
12346 pub const EPOCH_FIELD: &'static MessageField = &MessageField {
12347 name: "epoch",
12348 json_name: "epoch",
12349 number: 3i32,
12350 message_fields: None,
12351 };
12352 }
12353 impl MessageFields for ActiveJwk {
12354 const FIELDS: &'static [&'static MessageField] = &[
12355 Self::ID_FIELD,
12356 Self::JWK_FIELD,
12357 Self::EPOCH_FIELD,
12358 ];
12359 }
12360 impl ActiveJwk {
12361 pub fn path_builder() -> ActiveJwkFieldPathBuilder {
12362 ActiveJwkFieldPathBuilder::new()
12363 }
12364 }
12365 pub struct ActiveJwkFieldPathBuilder {
12366 path: Vec<&'static str>,
12367 }
12368 impl ActiveJwkFieldPathBuilder {
12369 #[allow(clippy::new_without_default)]
12370 pub fn new() -> Self {
12371 Self { path: Default::default() }
12372 }
12373 #[doc(hidden)]
12374 pub fn new_with_base(base: Vec<&'static str>) -> Self {
12375 Self { path: base }
12376 }
12377 pub fn finish(self) -> String {
12378 self.path.join(".")
12379 }
12380 pub fn id(mut self) -> JwkIdFieldPathBuilder {
12381 self.path.push(ActiveJwk::ID_FIELD.name);
12382 JwkIdFieldPathBuilder::new_with_base(self.path)
12383 }
12384 pub fn jwk(mut self) -> JwkFieldPathBuilder {
12385 self.path.push(ActiveJwk::JWK_FIELD.name);
12386 JwkFieldPathBuilder::new_with_base(self.path)
12387 }
12388 pub fn epoch(mut self) -> String {
12389 self.path.push(ActiveJwk::EPOCH_FIELD.name);
12390 self.finish()
12391 }
12392 }
12393 impl EndOfEpochTransaction {
12394 pub const TRANSACTIONS_FIELD: &'static MessageField = &MessageField {
12395 name: "transactions",
12396 json_name: "transactions",
12397 number: 1i32,
12398 message_fields: Some(EndOfEpochTransactionKind::FIELDS),
12399 };
12400 }
12401 impl MessageFields for EndOfEpochTransaction {
12402 const FIELDS: &'static [&'static MessageField] = &[Self::TRANSACTIONS_FIELD];
12403 }
12404 impl EndOfEpochTransaction {
12405 pub fn path_builder() -> EndOfEpochTransactionFieldPathBuilder {
12406 EndOfEpochTransactionFieldPathBuilder::new()
12407 }
12408 }
12409 pub struct EndOfEpochTransactionFieldPathBuilder {
12410 path: Vec<&'static str>,
12411 }
12412 impl EndOfEpochTransactionFieldPathBuilder {
12413 #[allow(clippy::new_without_default)]
12414 pub fn new() -> Self {
12415 Self { path: Default::default() }
12416 }
12417 #[doc(hidden)]
12418 pub fn new_with_base(base: Vec<&'static str>) -> Self {
12419 Self { path: base }
12420 }
12421 pub fn finish(self) -> String {
12422 self.path.join(".")
12423 }
12424 pub fn transactions(mut self) -> EndOfEpochTransactionKindFieldPathBuilder {
12425 self.path.push(EndOfEpochTransaction::TRANSACTIONS_FIELD.name);
12426 EndOfEpochTransactionKindFieldPathBuilder::new_with_base(self.path)
12427 }
12428 }
12429 impl EndOfEpochTransactionKind {
12430 pub const KIND_FIELD: &'static MessageField = &MessageField {
12431 name: "kind",
12432 json_name: "kind",
12433 number: 1i32,
12434 message_fields: None,
12435 };
12436 pub const CHANGE_EPOCH_FIELD: &'static MessageField = &MessageField {
12437 name: "change_epoch",
12438 json_name: "changeEpoch",
12439 number: 2i32,
12440 message_fields: Some(ChangeEpoch::FIELDS),
12441 };
12442 pub const AUTHENTICATOR_STATE_EXPIRE_FIELD: &'static MessageField = &MessageField {
12443 name: "authenticator_state_expire",
12444 json_name: "authenticatorStateExpire",
12445 number: 3i32,
12446 message_fields: Some(AuthenticatorStateExpire::FIELDS),
12447 };
12448 pub const EXECUTION_TIME_OBSERVATIONS_FIELD: &'static MessageField = &MessageField {
12449 name: "execution_time_observations",
12450 json_name: "executionTimeObservations",
12451 number: 4i32,
12452 message_fields: Some(ExecutionTimeObservations::FIELDS),
12453 };
12454 pub const BRIDGE_CHAIN_ID_FIELD: &'static MessageField = &MessageField {
12455 name: "bridge_chain_id",
12456 json_name: "bridgeChainId",
12457 number: 5i32,
12458 message_fields: None,
12459 };
12460 pub const BRIDGE_OBJECT_VERSION_FIELD: &'static MessageField = &MessageField {
12461 name: "bridge_object_version",
12462 json_name: "bridgeObjectVersion",
12463 number: 6i32,
12464 message_fields: None,
12465 };
12466 pub const STORAGE_COST_FIELD: &'static MessageField = &MessageField {
12467 name: "storage_cost",
12468 json_name: "storageCost",
12469 number: 7i32,
12470 message_fields: None,
12471 };
12472 }
12473 impl MessageFields for EndOfEpochTransactionKind {
12474 const FIELDS: &'static [&'static MessageField] = &[
12475 Self::KIND_FIELD,
12476 Self::CHANGE_EPOCH_FIELD,
12477 Self::AUTHENTICATOR_STATE_EXPIRE_FIELD,
12478 Self::EXECUTION_TIME_OBSERVATIONS_FIELD,
12479 Self::BRIDGE_CHAIN_ID_FIELD,
12480 Self::BRIDGE_OBJECT_VERSION_FIELD,
12481 Self::STORAGE_COST_FIELD,
12482 ];
12483 }
12484 impl EndOfEpochTransactionKind {
12485 pub fn path_builder() -> EndOfEpochTransactionKindFieldPathBuilder {
12486 EndOfEpochTransactionKindFieldPathBuilder::new()
12487 }
12488 }
12489 pub struct EndOfEpochTransactionKindFieldPathBuilder {
12490 path: Vec<&'static str>,
12491 }
12492 impl EndOfEpochTransactionKindFieldPathBuilder {
12493 #[allow(clippy::new_without_default)]
12494 pub fn new() -> Self {
12495 Self { path: Default::default() }
12496 }
12497 #[doc(hidden)]
12498 pub fn new_with_base(base: Vec<&'static str>) -> Self {
12499 Self { path: base }
12500 }
12501 pub fn finish(self) -> String {
12502 self.path.join(".")
12503 }
12504 pub fn kind(mut self) -> String {
12505 self.path.push(EndOfEpochTransactionKind::KIND_FIELD.name);
12506 self.finish()
12507 }
12508 pub fn change_epoch(mut self) -> ChangeEpochFieldPathBuilder {
12509 self.path.push(EndOfEpochTransactionKind::CHANGE_EPOCH_FIELD.name);
12510 ChangeEpochFieldPathBuilder::new_with_base(self.path)
12511 }
12512 pub fn authenticator_state_expire(
12513 mut self,
12514 ) -> AuthenticatorStateExpireFieldPathBuilder {
12515 self.path
12516 .push(EndOfEpochTransactionKind::AUTHENTICATOR_STATE_EXPIRE_FIELD.name);
12517 AuthenticatorStateExpireFieldPathBuilder::new_with_base(self.path)
12518 }
12519 pub fn execution_time_observations(
12520 mut self,
12521 ) -> ExecutionTimeObservationsFieldPathBuilder {
12522 self.path
12523 .push(EndOfEpochTransactionKind::EXECUTION_TIME_OBSERVATIONS_FIELD.name);
12524 ExecutionTimeObservationsFieldPathBuilder::new_with_base(self.path)
12525 }
12526 pub fn bridge_chain_id(mut self) -> String {
12527 self.path.push(EndOfEpochTransactionKind::BRIDGE_CHAIN_ID_FIELD.name);
12528 self.finish()
12529 }
12530 pub fn bridge_object_version(mut self) -> String {
12531 self.path.push(EndOfEpochTransactionKind::BRIDGE_OBJECT_VERSION_FIELD.name);
12532 self.finish()
12533 }
12534 pub fn storage_cost(mut self) -> String {
12535 self.path.push(EndOfEpochTransactionKind::STORAGE_COST_FIELD.name);
12536 self.finish()
12537 }
12538 }
12539 impl AuthenticatorStateExpire {
12540 pub const MIN_EPOCH_FIELD: &'static MessageField = &MessageField {
12541 name: "min_epoch",
12542 json_name: "minEpoch",
12543 number: 1i32,
12544 message_fields: None,
12545 };
12546 pub const AUTHENTICATOR_OBJECT_INITIAL_SHARED_VERSION_FIELD: &'static MessageField = &MessageField {
12547 name: "authenticator_object_initial_shared_version",
12548 json_name: "authenticatorObjectInitialSharedVersion",
12549 number: 2i32,
12550 message_fields: None,
12551 };
12552 }
12553 impl MessageFields for AuthenticatorStateExpire {
12554 const FIELDS: &'static [&'static MessageField] = &[
12555 Self::MIN_EPOCH_FIELD,
12556 Self::AUTHENTICATOR_OBJECT_INITIAL_SHARED_VERSION_FIELD,
12557 ];
12558 }
12559 impl AuthenticatorStateExpire {
12560 pub fn path_builder() -> AuthenticatorStateExpireFieldPathBuilder {
12561 AuthenticatorStateExpireFieldPathBuilder::new()
12562 }
12563 }
12564 pub struct AuthenticatorStateExpireFieldPathBuilder {
12565 path: Vec<&'static str>,
12566 }
12567 impl AuthenticatorStateExpireFieldPathBuilder {
12568 #[allow(clippy::new_without_default)]
12569 pub fn new() -> Self {
12570 Self { path: Default::default() }
12571 }
12572 #[doc(hidden)]
12573 pub fn new_with_base(base: Vec<&'static str>) -> Self {
12574 Self { path: base }
12575 }
12576 pub fn finish(self) -> String {
12577 self.path.join(".")
12578 }
12579 pub fn min_epoch(mut self) -> String {
12580 self.path.push(AuthenticatorStateExpire::MIN_EPOCH_FIELD.name);
12581 self.finish()
12582 }
12583 pub fn authenticator_object_initial_shared_version(mut self) -> String {
12584 self.path
12585 .push(
12586 AuthenticatorStateExpire::AUTHENTICATOR_OBJECT_INITIAL_SHARED_VERSION_FIELD
12587 .name,
12588 );
12589 self.finish()
12590 }
12591 }
12592 impl ExecutionTimeObservations {
12593 pub const VERSION_FIELD: &'static MessageField = &MessageField {
12594 name: "version",
12595 json_name: "version",
12596 number: 1i32,
12597 message_fields: None,
12598 };
12599 pub const OBSERVATIONS_FIELD: &'static MessageField = &MessageField {
12600 name: "observations",
12601 json_name: "observations",
12602 number: 2i32,
12603 message_fields: Some(ExecutionTimeObservation::FIELDS),
12604 };
12605 }
12606 impl MessageFields for ExecutionTimeObservations {
12607 const FIELDS: &'static [&'static MessageField] = &[
12608 Self::VERSION_FIELD,
12609 Self::OBSERVATIONS_FIELD,
12610 ];
12611 }
12612 impl ExecutionTimeObservations {
12613 pub fn path_builder() -> ExecutionTimeObservationsFieldPathBuilder {
12614 ExecutionTimeObservationsFieldPathBuilder::new()
12615 }
12616 }
12617 pub struct ExecutionTimeObservationsFieldPathBuilder {
12618 path: Vec<&'static str>,
12619 }
12620 impl ExecutionTimeObservationsFieldPathBuilder {
12621 #[allow(clippy::new_without_default)]
12622 pub fn new() -> Self {
12623 Self { path: Default::default() }
12624 }
12625 #[doc(hidden)]
12626 pub fn new_with_base(base: Vec<&'static str>) -> Self {
12627 Self { path: base }
12628 }
12629 pub fn finish(self) -> String {
12630 self.path.join(".")
12631 }
12632 pub fn version(mut self) -> String {
12633 self.path.push(ExecutionTimeObservations::VERSION_FIELD.name);
12634 self.finish()
12635 }
12636 pub fn observations(mut self) -> ExecutionTimeObservationFieldPathBuilder {
12637 self.path.push(ExecutionTimeObservations::OBSERVATIONS_FIELD.name);
12638 ExecutionTimeObservationFieldPathBuilder::new_with_base(self.path)
12639 }
12640 }
12641 impl ExecutionTimeObservation {
12642 pub const KIND_FIELD: &'static MessageField = &MessageField {
12643 name: "kind",
12644 json_name: "kind",
12645 number: 1i32,
12646 message_fields: None,
12647 };
12648 pub const MOVE_ENTRY_POINT_FIELD: &'static MessageField = &MessageField {
12649 name: "move_entry_point",
12650 json_name: "moveEntryPoint",
12651 number: 2i32,
12652 message_fields: Some(MoveCall::FIELDS),
12653 };
12654 pub const VALIDATOR_OBSERVATIONS_FIELD: &'static MessageField = &MessageField {
12655 name: "validator_observations",
12656 json_name: "validatorObservations",
12657 number: 3i32,
12658 message_fields: Some(ValidatorExecutionTimeObservation::FIELDS),
12659 };
12660 }
12661 impl MessageFields for ExecutionTimeObservation {
12662 const FIELDS: &'static [&'static MessageField] = &[
12663 Self::KIND_FIELD,
12664 Self::MOVE_ENTRY_POINT_FIELD,
12665 Self::VALIDATOR_OBSERVATIONS_FIELD,
12666 ];
12667 }
12668 impl ExecutionTimeObservation {
12669 pub fn path_builder() -> ExecutionTimeObservationFieldPathBuilder {
12670 ExecutionTimeObservationFieldPathBuilder::new()
12671 }
12672 }
12673 pub struct ExecutionTimeObservationFieldPathBuilder {
12674 path: Vec<&'static str>,
12675 }
12676 impl ExecutionTimeObservationFieldPathBuilder {
12677 #[allow(clippy::new_without_default)]
12678 pub fn new() -> Self {
12679 Self { path: Default::default() }
12680 }
12681 #[doc(hidden)]
12682 pub fn new_with_base(base: Vec<&'static str>) -> Self {
12683 Self { path: base }
12684 }
12685 pub fn finish(self) -> String {
12686 self.path.join(".")
12687 }
12688 pub fn kind(mut self) -> String {
12689 self.path.push(ExecutionTimeObservation::KIND_FIELD.name);
12690 self.finish()
12691 }
12692 pub fn move_entry_point(mut self) -> MoveCallFieldPathBuilder {
12693 self.path.push(ExecutionTimeObservation::MOVE_ENTRY_POINT_FIELD.name);
12694 MoveCallFieldPathBuilder::new_with_base(self.path)
12695 }
12696 pub fn validator_observations(
12697 mut self,
12698 ) -> ValidatorExecutionTimeObservationFieldPathBuilder {
12699 self.path.push(ExecutionTimeObservation::VALIDATOR_OBSERVATIONS_FIELD.name);
12700 ValidatorExecutionTimeObservationFieldPathBuilder::new_with_base(self.path)
12701 }
12702 }
12703 impl ValidatorExecutionTimeObservation {
12704 pub const VALIDATOR_FIELD: &'static MessageField = &MessageField {
12705 name: "validator",
12706 json_name: "validator",
12707 number: 1i32,
12708 message_fields: None,
12709 };
12710 pub const DURATION_FIELD: &'static MessageField = &MessageField {
12711 name: "duration",
12712 json_name: "duration",
12713 number: 2i32,
12714 message_fields: None,
12715 };
12716 }
12717 impl MessageFields for ValidatorExecutionTimeObservation {
12718 const FIELDS: &'static [&'static MessageField] = &[
12719 Self::VALIDATOR_FIELD,
12720 Self::DURATION_FIELD,
12721 ];
12722 }
12723 impl ValidatorExecutionTimeObservation {
12724 pub fn path_builder() -> ValidatorExecutionTimeObservationFieldPathBuilder {
12725 ValidatorExecutionTimeObservationFieldPathBuilder::new()
12726 }
12727 }
12728 pub struct ValidatorExecutionTimeObservationFieldPathBuilder {
12729 path: Vec<&'static str>,
12730 }
12731 impl ValidatorExecutionTimeObservationFieldPathBuilder {
12732 #[allow(clippy::new_without_default)]
12733 pub fn new() -> Self {
12734 Self { path: Default::default() }
12735 }
12736 #[doc(hidden)]
12737 pub fn new_with_base(base: Vec<&'static str>) -> Self {
12738 Self { path: base }
12739 }
12740 pub fn finish(self) -> String {
12741 self.path.join(".")
12742 }
12743 pub fn validator(mut self) -> String {
12744 self.path.push(ValidatorExecutionTimeObservation::VALIDATOR_FIELD.name);
12745 self.finish()
12746 }
12747 pub fn duration(mut self) -> String {
12748 self.path.push(ValidatorExecutionTimeObservation::DURATION_FIELD.name);
12749 self.finish()
12750 }
12751 }
12752 impl ExecuteTransactionRequest {
12753 pub const TRANSACTION_FIELD: &'static MessageField = &MessageField {
12754 name: "transaction",
12755 json_name: "transaction",
12756 number: 1i32,
12757 message_fields: Some(Transaction::FIELDS),
12758 };
12759 pub const SIGNATURES_FIELD: &'static MessageField = &MessageField {
12760 name: "signatures",
12761 json_name: "signatures",
12762 number: 2i32,
12763 message_fields: Some(UserSignature::FIELDS),
12764 };
12765 pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
12766 name: "read_mask",
12767 json_name: "readMask",
12768 number: 3i32,
12769 message_fields: None,
12770 };
12771 }
12772 impl MessageFields for ExecuteTransactionRequest {
12773 const FIELDS: &'static [&'static MessageField] = &[
12774 Self::TRANSACTION_FIELD,
12775 Self::SIGNATURES_FIELD,
12776 Self::READ_MASK_FIELD,
12777 ];
12778 }
12779 impl ExecuteTransactionRequest {
12780 pub fn path_builder() -> ExecuteTransactionRequestFieldPathBuilder {
12781 ExecuteTransactionRequestFieldPathBuilder::new()
12782 }
12783 }
12784 pub struct ExecuteTransactionRequestFieldPathBuilder {
12785 path: Vec<&'static str>,
12786 }
12787 impl ExecuteTransactionRequestFieldPathBuilder {
12788 #[allow(clippy::new_without_default)]
12789 pub fn new() -> Self {
12790 Self { path: Default::default() }
12791 }
12792 #[doc(hidden)]
12793 pub fn new_with_base(base: Vec<&'static str>) -> Self {
12794 Self { path: base }
12795 }
12796 pub fn finish(self) -> String {
12797 self.path.join(".")
12798 }
12799 pub fn transaction(mut self) -> TransactionFieldPathBuilder {
12800 self.path.push(ExecuteTransactionRequest::TRANSACTION_FIELD.name);
12801 TransactionFieldPathBuilder::new_with_base(self.path)
12802 }
12803 pub fn signatures(mut self) -> UserSignatureFieldPathBuilder {
12804 self.path.push(ExecuteTransactionRequest::SIGNATURES_FIELD.name);
12805 UserSignatureFieldPathBuilder::new_with_base(self.path)
12806 }
12807 pub fn read_mask(mut self) -> String {
12808 self.path.push(ExecuteTransactionRequest::READ_MASK_FIELD.name);
12809 self.finish()
12810 }
12811 }
12812 impl ExecuteTransactionResponse {
12813 pub const TRANSACTION_FIELD: &'static MessageField = &MessageField {
12814 name: "transaction",
12815 json_name: "transaction",
12816 number: 1i32,
12817 message_fields: Some(ExecutedTransaction::FIELDS),
12818 };
12819 }
12820 impl MessageFields for ExecuteTransactionResponse {
12821 const FIELDS: &'static [&'static MessageField] = &[Self::TRANSACTION_FIELD];
12822 }
12823 impl ExecuteTransactionResponse {
12824 pub fn path_builder() -> ExecuteTransactionResponseFieldPathBuilder {
12825 ExecuteTransactionResponseFieldPathBuilder::new()
12826 }
12827 }
12828 pub struct ExecuteTransactionResponseFieldPathBuilder {
12829 path: Vec<&'static str>,
12830 }
12831 impl ExecuteTransactionResponseFieldPathBuilder {
12832 #[allow(clippy::new_without_default)]
12833 pub fn new() -> Self {
12834 Self { path: Default::default() }
12835 }
12836 #[doc(hidden)]
12837 pub fn new_with_base(base: Vec<&'static str>) -> Self {
12838 Self { path: base }
12839 }
12840 pub fn finish(self) -> String {
12841 self.path.join(".")
12842 }
12843 pub fn transaction(mut self) -> ExecutedTransactionFieldPathBuilder {
12844 self.path.push(ExecuteTransactionResponse::TRANSACTION_FIELD.name);
12845 ExecutedTransactionFieldPathBuilder::new_with_base(self.path)
12846 }
12847 }
12848 impl SimulateTransactionRequest {
12849 pub const TRANSACTION_FIELD: &'static MessageField = &MessageField {
12850 name: "transaction",
12851 json_name: "transaction",
12852 number: 1i32,
12853 message_fields: Some(Transaction::FIELDS),
12854 };
12855 pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
12856 name: "read_mask",
12857 json_name: "readMask",
12858 number: 2i32,
12859 message_fields: None,
12860 };
12861 pub const CHECKS_FIELD: &'static MessageField = &MessageField {
12862 name: "checks",
12863 json_name: "checks",
12864 number: 3i32,
12865 message_fields: None,
12866 };
12867 pub const DO_GAS_SELECTION_FIELD: &'static MessageField = &MessageField {
12868 name: "do_gas_selection",
12869 json_name: "doGasSelection",
12870 number: 4i32,
12871 message_fields: None,
12872 };
12873 }
12874 impl MessageFields for SimulateTransactionRequest {
12875 const FIELDS: &'static [&'static MessageField] = &[
12876 Self::TRANSACTION_FIELD,
12877 Self::READ_MASK_FIELD,
12878 Self::CHECKS_FIELD,
12879 Self::DO_GAS_SELECTION_FIELD,
12880 ];
12881 }
12882 impl SimulateTransactionRequest {
12883 pub fn path_builder() -> SimulateTransactionRequestFieldPathBuilder {
12884 SimulateTransactionRequestFieldPathBuilder::new()
12885 }
12886 }
12887 pub struct SimulateTransactionRequestFieldPathBuilder {
12888 path: Vec<&'static str>,
12889 }
12890 impl SimulateTransactionRequestFieldPathBuilder {
12891 #[allow(clippy::new_without_default)]
12892 pub fn new() -> Self {
12893 Self { path: Default::default() }
12894 }
12895 #[doc(hidden)]
12896 pub fn new_with_base(base: Vec<&'static str>) -> Self {
12897 Self { path: base }
12898 }
12899 pub fn finish(self) -> String {
12900 self.path.join(".")
12901 }
12902 pub fn transaction(mut self) -> TransactionFieldPathBuilder {
12903 self.path.push(SimulateTransactionRequest::TRANSACTION_FIELD.name);
12904 TransactionFieldPathBuilder::new_with_base(self.path)
12905 }
12906 pub fn read_mask(mut self) -> String {
12907 self.path.push(SimulateTransactionRequest::READ_MASK_FIELD.name);
12908 self.finish()
12909 }
12910 pub fn checks(mut self) -> String {
12911 self.path.push(SimulateTransactionRequest::CHECKS_FIELD.name);
12912 self.finish()
12913 }
12914 pub fn do_gas_selection(mut self) -> String {
12915 self.path.push(SimulateTransactionRequest::DO_GAS_SELECTION_FIELD.name);
12916 self.finish()
12917 }
12918 }
12919 impl SimulateTransactionResponse {
12920 pub const TRANSACTION_FIELD: &'static MessageField = &MessageField {
12921 name: "transaction",
12922 json_name: "transaction",
12923 number: 1i32,
12924 message_fields: Some(ExecutedTransaction::FIELDS),
12925 };
12926 pub const COMMAND_OUTPUTS_FIELD: &'static MessageField = &MessageField {
12927 name: "command_outputs",
12928 json_name: "commandOutputs",
12929 number: 2i32,
12930 message_fields: Some(CommandResult::FIELDS),
12931 };
12932 pub const SUGGESTED_GAS_PRICE_FIELD: &'static MessageField = &MessageField {
12933 name: "suggested_gas_price",
12934 json_name: "suggestedGasPrice",
12935 number: 3i32,
12936 message_fields: None,
12937 };
12938 }
12939 impl MessageFields for SimulateTransactionResponse {
12940 const FIELDS: &'static [&'static MessageField] = &[
12941 Self::TRANSACTION_FIELD,
12942 Self::COMMAND_OUTPUTS_FIELD,
12943 Self::SUGGESTED_GAS_PRICE_FIELD,
12944 ];
12945 }
12946 impl SimulateTransactionResponse {
12947 pub fn path_builder() -> SimulateTransactionResponseFieldPathBuilder {
12948 SimulateTransactionResponseFieldPathBuilder::new()
12949 }
12950 }
12951 pub struct SimulateTransactionResponseFieldPathBuilder {
12952 path: Vec<&'static str>,
12953 }
12954 impl SimulateTransactionResponseFieldPathBuilder {
12955 #[allow(clippy::new_without_default)]
12956 pub fn new() -> Self {
12957 Self { path: Default::default() }
12958 }
12959 #[doc(hidden)]
12960 pub fn new_with_base(base: Vec<&'static str>) -> Self {
12961 Self { path: base }
12962 }
12963 pub fn finish(self) -> String {
12964 self.path.join(".")
12965 }
12966 pub fn transaction(mut self) -> ExecutedTransactionFieldPathBuilder {
12967 self.path.push(SimulateTransactionResponse::TRANSACTION_FIELD.name);
12968 ExecutedTransactionFieldPathBuilder::new_with_base(self.path)
12969 }
12970 pub fn command_outputs(mut self) -> CommandResultFieldPathBuilder {
12971 self.path.push(SimulateTransactionResponse::COMMAND_OUTPUTS_FIELD.name);
12972 CommandResultFieldPathBuilder::new_with_base(self.path)
12973 }
12974 pub fn suggested_gas_price(mut self) -> String {
12975 self.path.push(SimulateTransactionResponse::SUGGESTED_GAS_PRICE_FIELD.name);
12976 self.finish()
12977 }
12978 }
12979 impl CommandResult {
12980 pub const RETURN_VALUES_FIELD: &'static MessageField = &MessageField {
12981 name: "return_values",
12982 json_name: "returnValues",
12983 number: 1i32,
12984 message_fields: Some(CommandOutput::FIELDS),
12985 };
12986 pub const MUTATED_BY_REF_FIELD: &'static MessageField = &MessageField {
12987 name: "mutated_by_ref",
12988 json_name: "mutatedByRef",
12989 number: 2i32,
12990 message_fields: Some(CommandOutput::FIELDS),
12991 };
12992 }
12993 impl MessageFields for CommandResult {
12994 const FIELDS: &'static [&'static MessageField] = &[
12995 Self::RETURN_VALUES_FIELD,
12996 Self::MUTATED_BY_REF_FIELD,
12997 ];
12998 }
12999 impl CommandResult {
13000 pub fn path_builder() -> CommandResultFieldPathBuilder {
13001 CommandResultFieldPathBuilder::new()
13002 }
13003 }
13004 pub struct CommandResultFieldPathBuilder {
13005 path: Vec<&'static str>,
13006 }
13007 impl CommandResultFieldPathBuilder {
13008 #[allow(clippy::new_without_default)]
13009 pub fn new() -> Self {
13010 Self { path: Default::default() }
13011 }
13012 #[doc(hidden)]
13013 pub fn new_with_base(base: Vec<&'static str>) -> Self {
13014 Self { path: base }
13015 }
13016 pub fn finish(self) -> String {
13017 self.path.join(".")
13018 }
13019 pub fn return_values(mut self) -> CommandOutputFieldPathBuilder {
13020 self.path.push(CommandResult::RETURN_VALUES_FIELD.name);
13021 CommandOutputFieldPathBuilder::new_with_base(self.path)
13022 }
13023 pub fn mutated_by_ref(mut self) -> CommandOutputFieldPathBuilder {
13024 self.path.push(CommandResult::MUTATED_BY_REF_FIELD.name);
13025 CommandOutputFieldPathBuilder::new_with_base(self.path)
13026 }
13027 }
13028 impl CommandOutput {
13029 pub const ARGUMENT_FIELD: &'static MessageField = &MessageField {
13030 name: "argument",
13031 json_name: "argument",
13032 number: 1i32,
13033 message_fields: Some(Argument::FIELDS),
13034 };
13035 pub const VALUE_FIELD: &'static MessageField = &MessageField {
13036 name: "value",
13037 json_name: "value",
13038 number: 2i32,
13039 message_fields: Some(Bcs::FIELDS),
13040 };
13041 pub const JSON_FIELD: &'static MessageField = &MessageField {
13042 name: "json",
13043 json_name: "json",
13044 number: 3i32,
13045 message_fields: None,
13046 };
13047 }
13048 impl MessageFields for CommandOutput {
13049 const FIELDS: &'static [&'static MessageField] = &[
13050 Self::ARGUMENT_FIELD,
13051 Self::VALUE_FIELD,
13052 Self::JSON_FIELD,
13053 ];
13054 }
13055 impl CommandOutput {
13056 pub fn path_builder() -> CommandOutputFieldPathBuilder {
13057 CommandOutputFieldPathBuilder::new()
13058 }
13059 }
13060 pub struct CommandOutputFieldPathBuilder {
13061 path: Vec<&'static str>,
13062 }
13063 impl CommandOutputFieldPathBuilder {
13064 #[allow(clippy::new_without_default)]
13065 pub fn new() -> Self {
13066 Self { path: Default::default() }
13067 }
13068 #[doc(hidden)]
13069 pub fn new_with_base(base: Vec<&'static str>) -> Self {
13070 Self { path: base }
13071 }
13072 pub fn finish(self) -> String {
13073 self.path.join(".")
13074 }
13075 pub fn argument(mut self) -> ArgumentFieldPathBuilder {
13076 self.path.push(CommandOutput::ARGUMENT_FIELD.name);
13077 ArgumentFieldPathBuilder::new_with_base(self.path)
13078 }
13079 pub fn value(mut self) -> BcsFieldPathBuilder {
13080 self.path.push(CommandOutput::VALUE_FIELD.name);
13081 BcsFieldPathBuilder::new_with_base(self.path)
13082 }
13083 pub fn json(mut self) -> String {
13084 self.path.push(CommandOutput::JSON_FIELD.name);
13085 self.finish()
13086 }
13087 }
13088}