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