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