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