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