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