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 }
3457 impl MessageFields for FundsWithdrawal {
3458 const FIELDS: &'static [&'static MessageField] = &[
3459 Self::AMOUNT_FIELD,
3460 Self::COIN_TYPE_FIELD,
3461 Self::SOURCE_FIELD,
3462 ];
3463 }
3464 impl FundsWithdrawal {
3465 pub fn path_builder() -> FundsWithdrawalFieldPathBuilder {
3466 FundsWithdrawalFieldPathBuilder::new()
3467 }
3468 }
3469 pub struct FundsWithdrawalFieldPathBuilder {
3470 path: Vec<&'static str>,
3471 }
3472 impl FundsWithdrawalFieldPathBuilder {
3473 #[allow(clippy::new_without_default)]
3474 pub fn new() -> Self {
3475 Self { path: Default::default() }
3476 }
3477 #[doc(hidden)]
3478 pub fn new_with_base(base: Vec<&'static str>) -> Self {
3479 Self { path: base }
3480 }
3481 pub fn finish(self) -> String {
3482 self.path.join(".")
3483 }
3484 pub fn amount(mut self) -> String {
3485 self.path.push(FundsWithdrawal::AMOUNT_FIELD.name);
3486 self.finish()
3487 }
3488 pub fn coin_type(mut self) -> String {
3489 self.path.push(FundsWithdrawal::COIN_TYPE_FIELD.name);
3490 self.finish()
3491 }
3492 pub fn source(mut self) -> String {
3493 self.path.push(FundsWithdrawal::SOURCE_FIELD.name);
3494 self.finish()
3495 }
3496 }
3497 impl JwkId {
3498 pub const ISS_FIELD: &'static MessageField = &MessageField {
3499 name: "iss",
3500 json_name: "iss",
3501 number: 1i32,
3502 message_fields: None,
3503 };
3504 pub const KID_FIELD: &'static MessageField = &MessageField {
3505 name: "kid",
3506 json_name: "kid",
3507 number: 2i32,
3508 message_fields: None,
3509 };
3510 }
3511 impl MessageFields for JwkId {
3512 const FIELDS: &'static [&'static MessageField] = &[
3513 Self::ISS_FIELD,
3514 Self::KID_FIELD,
3515 ];
3516 }
3517 impl JwkId {
3518 pub fn path_builder() -> JwkIdFieldPathBuilder {
3519 JwkIdFieldPathBuilder::new()
3520 }
3521 }
3522 pub struct JwkIdFieldPathBuilder {
3523 path: Vec<&'static str>,
3524 }
3525 impl JwkIdFieldPathBuilder {
3526 #[allow(clippy::new_without_default)]
3527 pub fn new() -> Self {
3528 Self { path: Default::default() }
3529 }
3530 #[doc(hidden)]
3531 pub fn new_with_base(base: Vec<&'static str>) -> Self {
3532 Self { path: base }
3533 }
3534 pub fn finish(self) -> String {
3535 self.path.join(".")
3536 }
3537 pub fn iss(mut self) -> String {
3538 self.path.push(JwkId::ISS_FIELD.name);
3539 self.finish()
3540 }
3541 pub fn kid(mut self) -> String {
3542 self.path.push(JwkId::KID_FIELD.name);
3543 self.finish()
3544 }
3545 }
3546 impl Jwk {
3547 pub const KTY_FIELD: &'static MessageField = &MessageField {
3548 name: "kty",
3549 json_name: "kty",
3550 number: 1i32,
3551 message_fields: None,
3552 };
3553 pub const E_FIELD: &'static MessageField = &MessageField {
3554 name: "e",
3555 json_name: "e",
3556 number: 2i32,
3557 message_fields: None,
3558 };
3559 pub const N_FIELD: &'static MessageField = &MessageField {
3560 name: "n",
3561 json_name: "n",
3562 number: 3i32,
3563 message_fields: None,
3564 };
3565 pub const ALG_FIELD: &'static MessageField = &MessageField {
3566 name: "alg",
3567 json_name: "alg",
3568 number: 4i32,
3569 message_fields: None,
3570 };
3571 }
3572 impl MessageFields for Jwk {
3573 const FIELDS: &'static [&'static MessageField] = &[
3574 Self::KTY_FIELD,
3575 Self::E_FIELD,
3576 Self::N_FIELD,
3577 Self::ALG_FIELD,
3578 ];
3579 }
3580 impl Jwk {
3581 pub fn path_builder() -> JwkFieldPathBuilder {
3582 JwkFieldPathBuilder::new()
3583 }
3584 }
3585 pub struct JwkFieldPathBuilder {
3586 path: Vec<&'static str>,
3587 }
3588 impl JwkFieldPathBuilder {
3589 #[allow(clippy::new_without_default)]
3590 pub fn new() -> Self {
3591 Self { path: Default::default() }
3592 }
3593 #[doc(hidden)]
3594 pub fn new_with_base(base: Vec<&'static str>) -> Self {
3595 Self { path: base }
3596 }
3597 pub fn finish(self) -> String {
3598 self.path.join(".")
3599 }
3600 pub fn kty(mut self) -> String {
3601 self.path.push(Jwk::KTY_FIELD.name);
3602 self.finish()
3603 }
3604 pub fn e(mut self) -> String {
3605 self.path.push(Jwk::E_FIELD.name);
3606 self.finish()
3607 }
3608 pub fn n(mut self) -> String {
3609 self.path.push(Jwk::N_FIELD.name);
3610 self.finish()
3611 }
3612 pub fn alg(mut self) -> String {
3613 self.path.push(Jwk::ALG_FIELD.name);
3614 self.finish()
3615 }
3616 }
3617 impl GetServiceInfoRequest {}
3618 impl MessageFields for GetServiceInfoRequest {
3619 const FIELDS: &'static [&'static MessageField] = &[];
3620 }
3621 impl GetServiceInfoRequest {
3622 pub fn path_builder() -> GetServiceInfoRequestFieldPathBuilder {
3623 GetServiceInfoRequestFieldPathBuilder::new()
3624 }
3625 }
3626 pub struct GetServiceInfoRequestFieldPathBuilder {
3627 path: Vec<&'static str>,
3628 }
3629 impl GetServiceInfoRequestFieldPathBuilder {
3630 #[allow(clippy::new_without_default)]
3631 pub fn new() -> Self {
3632 Self { path: Default::default() }
3633 }
3634 #[doc(hidden)]
3635 pub fn new_with_base(base: Vec<&'static str>) -> Self {
3636 Self { path: base }
3637 }
3638 pub fn finish(self) -> String {
3639 self.path.join(".")
3640 }
3641 }
3642 impl GetServiceInfoResponse {
3643 pub const CHAIN_ID_FIELD: &'static MessageField = &MessageField {
3644 name: "chain_id",
3645 json_name: "chainId",
3646 number: 1i32,
3647 message_fields: None,
3648 };
3649 pub const CHAIN_FIELD: &'static MessageField = &MessageField {
3650 name: "chain",
3651 json_name: "chain",
3652 number: 2i32,
3653 message_fields: None,
3654 };
3655 pub const EPOCH_FIELD: &'static MessageField = &MessageField {
3656 name: "epoch",
3657 json_name: "epoch",
3658 number: 3i32,
3659 message_fields: None,
3660 };
3661 pub const CHECKPOINT_HEIGHT_FIELD: &'static MessageField = &MessageField {
3662 name: "checkpoint_height",
3663 json_name: "checkpointHeight",
3664 number: 4i32,
3665 message_fields: None,
3666 };
3667 pub const TIMESTAMP_FIELD: &'static MessageField = &MessageField {
3668 name: "timestamp",
3669 json_name: "timestamp",
3670 number: 5i32,
3671 message_fields: None,
3672 };
3673 pub const LOWEST_AVAILABLE_CHECKPOINT_FIELD: &'static MessageField = &MessageField {
3674 name: "lowest_available_checkpoint",
3675 json_name: "lowestAvailableCheckpoint",
3676 number: 6i32,
3677 message_fields: None,
3678 };
3679 pub const LOWEST_AVAILABLE_CHECKPOINT_OBJECTS_FIELD: &'static MessageField = &MessageField {
3680 name: "lowest_available_checkpoint_objects",
3681 json_name: "lowestAvailableCheckpointObjects",
3682 number: 7i32,
3683 message_fields: None,
3684 };
3685 pub const SERVER_FIELD: &'static MessageField = &MessageField {
3686 name: "server",
3687 json_name: "server",
3688 number: 8i32,
3689 message_fields: None,
3690 };
3691 }
3692 impl MessageFields for GetServiceInfoResponse {
3693 const FIELDS: &'static [&'static MessageField] = &[
3694 Self::CHAIN_ID_FIELD,
3695 Self::CHAIN_FIELD,
3696 Self::EPOCH_FIELD,
3697 Self::CHECKPOINT_HEIGHT_FIELD,
3698 Self::TIMESTAMP_FIELD,
3699 Self::LOWEST_AVAILABLE_CHECKPOINT_FIELD,
3700 Self::LOWEST_AVAILABLE_CHECKPOINT_OBJECTS_FIELD,
3701 Self::SERVER_FIELD,
3702 ];
3703 }
3704 impl GetServiceInfoResponse {
3705 pub fn path_builder() -> GetServiceInfoResponseFieldPathBuilder {
3706 GetServiceInfoResponseFieldPathBuilder::new()
3707 }
3708 }
3709 pub struct GetServiceInfoResponseFieldPathBuilder {
3710 path: Vec<&'static str>,
3711 }
3712 impl GetServiceInfoResponseFieldPathBuilder {
3713 #[allow(clippy::new_without_default)]
3714 pub fn new() -> Self {
3715 Self { path: Default::default() }
3716 }
3717 #[doc(hidden)]
3718 pub fn new_with_base(base: Vec<&'static str>) -> Self {
3719 Self { path: base }
3720 }
3721 pub fn finish(self) -> String {
3722 self.path.join(".")
3723 }
3724 pub fn chain_id(mut self) -> String {
3725 self.path.push(GetServiceInfoResponse::CHAIN_ID_FIELD.name);
3726 self.finish()
3727 }
3728 pub fn chain(mut self) -> String {
3729 self.path.push(GetServiceInfoResponse::CHAIN_FIELD.name);
3730 self.finish()
3731 }
3732 pub fn epoch(mut self) -> String {
3733 self.path.push(GetServiceInfoResponse::EPOCH_FIELD.name);
3734 self.finish()
3735 }
3736 pub fn checkpoint_height(mut self) -> String {
3737 self.path.push(GetServiceInfoResponse::CHECKPOINT_HEIGHT_FIELD.name);
3738 self.finish()
3739 }
3740 pub fn timestamp(mut self) -> String {
3741 self.path.push(GetServiceInfoResponse::TIMESTAMP_FIELD.name);
3742 self.finish()
3743 }
3744 pub fn lowest_available_checkpoint(mut self) -> String {
3745 self.path
3746 .push(GetServiceInfoResponse::LOWEST_AVAILABLE_CHECKPOINT_FIELD.name);
3747 self.finish()
3748 }
3749 pub fn lowest_available_checkpoint_objects(mut self) -> String {
3750 self.path
3751 .push(
3752 GetServiceInfoResponse::LOWEST_AVAILABLE_CHECKPOINT_OBJECTS_FIELD
3753 .name,
3754 );
3755 self.finish()
3756 }
3757 pub fn server(mut self) -> String {
3758 self.path.push(GetServiceInfoResponse::SERVER_FIELD.name);
3759 self.finish()
3760 }
3761 }
3762 impl GetObjectRequest {
3763 pub const OBJECT_ID_FIELD: &'static MessageField = &MessageField {
3764 name: "object_id",
3765 json_name: "objectId",
3766 number: 1i32,
3767 message_fields: None,
3768 };
3769 pub const VERSION_FIELD: &'static MessageField = &MessageField {
3770 name: "version",
3771 json_name: "version",
3772 number: 2i32,
3773 message_fields: None,
3774 };
3775 pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
3776 name: "read_mask",
3777 json_name: "readMask",
3778 number: 3i32,
3779 message_fields: None,
3780 };
3781 }
3782 impl MessageFields for GetObjectRequest {
3783 const FIELDS: &'static [&'static MessageField] = &[
3784 Self::OBJECT_ID_FIELD,
3785 Self::VERSION_FIELD,
3786 Self::READ_MASK_FIELD,
3787 ];
3788 }
3789 impl GetObjectRequest {
3790 pub fn path_builder() -> GetObjectRequestFieldPathBuilder {
3791 GetObjectRequestFieldPathBuilder::new()
3792 }
3793 }
3794 pub struct GetObjectRequestFieldPathBuilder {
3795 path: Vec<&'static str>,
3796 }
3797 impl GetObjectRequestFieldPathBuilder {
3798 #[allow(clippy::new_without_default)]
3799 pub fn new() -> Self {
3800 Self { path: Default::default() }
3801 }
3802 #[doc(hidden)]
3803 pub fn new_with_base(base: Vec<&'static str>) -> Self {
3804 Self { path: base }
3805 }
3806 pub fn finish(self) -> String {
3807 self.path.join(".")
3808 }
3809 pub fn object_id(mut self) -> String {
3810 self.path.push(GetObjectRequest::OBJECT_ID_FIELD.name);
3811 self.finish()
3812 }
3813 pub fn version(mut self) -> String {
3814 self.path.push(GetObjectRequest::VERSION_FIELD.name);
3815 self.finish()
3816 }
3817 pub fn read_mask(mut self) -> String {
3818 self.path.push(GetObjectRequest::READ_MASK_FIELD.name);
3819 self.finish()
3820 }
3821 }
3822 impl GetObjectResponse {
3823 pub const OBJECT_FIELD: &'static MessageField = &MessageField {
3824 name: "object",
3825 json_name: "object",
3826 number: 1i32,
3827 message_fields: Some(Object::FIELDS),
3828 };
3829 }
3830 impl MessageFields for GetObjectResponse {
3831 const FIELDS: &'static [&'static MessageField] = &[Self::OBJECT_FIELD];
3832 }
3833 impl GetObjectResponse {
3834 pub fn path_builder() -> GetObjectResponseFieldPathBuilder {
3835 GetObjectResponseFieldPathBuilder::new()
3836 }
3837 }
3838 pub struct GetObjectResponseFieldPathBuilder {
3839 path: Vec<&'static str>,
3840 }
3841 impl GetObjectResponseFieldPathBuilder {
3842 #[allow(clippy::new_without_default)]
3843 pub fn new() -> Self {
3844 Self { path: Default::default() }
3845 }
3846 #[doc(hidden)]
3847 pub fn new_with_base(base: Vec<&'static str>) -> Self {
3848 Self { path: base }
3849 }
3850 pub fn finish(self) -> String {
3851 self.path.join(".")
3852 }
3853 pub fn object(mut self) -> ObjectFieldPathBuilder {
3854 self.path.push(GetObjectResponse::OBJECT_FIELD.name);
3855 ObjectFieldPathBuilder::new_with_base(self.path)
3856 }
3857 }
3858 impl BatchGetObjectsRequest {
3859 pub const REQUESTS_FIELD: &'static MessageField = &MessageField {
3860 name: "requests",
3861 json_name: "requests",
3862 number: 1i32,
3863 message_fields: Some(GetObjectRequest::FIELDS),
3864 };
3865 pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
3866 name: "read_mask",
3867 json_name: "readMask",
3868 number: 2i32,
3869 message_fields: None,
3870 };
3871 }
3872 impl MessageFields for BatchGetObjectsRequest {
3873 const FIELDS: &'static [&'static MessageField] = &[
3874 Self::REQUESTS_FIELD,
3875 Self::READ_MASK_FIELD,
3876 ];
3877 }
3878 impl BatchGetObjectsRequest {
3879 pub fn path_builder() -> BatchGetObjectsRequestFieldPathBuilder {
3880 BatchGetObjectsRequestFieldPathBuilder::new()
3881 }
3882 }
3883 pub struct BatchGetObjectsRequestFieldPathBuilder {
3884 path: Vec<&'static str>,
3885 }
3886 impl BatchGetObjectsRequestFieldPathBuilder {
3887 #[allow(clippy::new_without_default)]
3888 pub fn new() -> Self {
3889 Self { path: Default::default() }
3890 }
3891 #[doc(hidden)]
3892 pub fn new_with_base(base: Vec<&'static str>) -> Self {
3893 Self { path: base }
3894 }
3895 pub fn finish(self) -> String {
3896 self.path.join(".")
3897 }
3898 pub fn requests(mut self) -> GetObjectRequestFieldPathBuilder {
3899 self.path.push(BatchGetObjectsRequest::REQUESTS_FIELD.name);
3900 GetObjectRequestFieldPathBuilder::new_with_base(self.path)
3901 }
3902 pub fn read_mask(mut self) -> String {
3903 self.path.push(BatchGetObjectsRequest::READ_MASK_FIELD.name);
3904 self.finish()
3905 }
3906 }
3907 impl BatchGetObjectsResponse {
3908 pub const OBJECTS_FIELD: &'static MessageField = &MessageField {
3909 name: "objects",
3910 json_name: "objects",
3911 number: 1i32,
3912 message_fields: Some(GetObjectResult::FIELDS),
3913 };
3914 }
3915 impl MessageFields for BatchGetObjectsResponse {
3916 const FIELDS: &'static [&'static MessageField] = &[Self::OBJECTS_FIELD];
3917 }
3918 impl BatchGetObjectsResponse {
3919 pub fn path_builder() -> BatchGetObjectsResponseFieldPathBuilder {
3920 BatchGetObjectsResponseFieldPathBuilder::new()
3921 }
3922 }
3923 pub struct BatchGetObjectsResponseFieldPathBuilder {
3924 path: Vec<&'static str>,
3925 }
3926 impl BatchGetObjectsResponseFieldPathBuilder {
3927 #[allow(clippy::new_without_default)]
3928 pub fn new() -> Self {
3929 Self { path: Default::default() }
3930 }
3931 #[doc(hidden)]
3932 pub fn new_with_base(base: Vec<&'static str>) -> Self {
3933 Self { path: base }
3934 }
3935 pub fn finish(self) -> String {
3936 self.path.join(".")
3937 }
3938 pub fn objects(mut self) -> GetObjectResultFieldPathBuilder {
3939 self.path.push(BatchGetObjectsResponse::OBJECTS_FIELD.name);
3940 GetObjectResultFieldPathBuilder::new_with_base(self.path)
3941 }
3942 }
3943 impl GetObjectResult {
3944 pub const OBJECT_FIELD: &'static MessageField = &MessageField {
3945 name: "object",
3946 json_name: "object",
3947 number: 1i32,
3948 message_fields: Some(Object::FIELDS),
3949 };
3950 pub const ERROR_FIELD: &'static MessageField = &MessageField {
3951 name: "error",
3952 json_name: "error",
3953 number: 2i32,
3954 message_fields: None,
3955 };
3956 }
3957 impl MessageFields for GetObjectResult {
3958 const FIELDS: &'static [&'static MessageField] = &[
3959 Self::OBJECT_FIELD,
3960 Self::ERROR_FIELD,
3961 ];
3962 }
3963 impl GetObjectResult {
3964 pub fn path_builder() -> GetObjectResultFieldPathBuilder {
3965 GetObjectResultFieldPathBuilder::new()
3966 }
3967 }
3968 pub struct GetObjectResultFieldPathBuilder {
3969 path: Vec<&'static str>,
3970 }
3971 impl GetObjectResultFieldPathBuilder {
3972 #[allow(clippy::new_without_default)]
3973 pub fn new() -> Self {
3974 Self { path: Default::default() }
3975 }
3976 #[doc(hidden)]
3977 pub fn new_with_base(base: Vec<&'static str>) -> Self {
3978 Self { path: base }
3979 }
3980 pub fn finish(self) -> String {
3981 self.path.join(".")
3982 }
3983 pub fn object(mut self) -> ObjectFieldPathBuilder {
3984 self.path.push(GetObjectResult::OBJECT_FIELD.name);
3985 ObjectFieldPathBuilder::new_with_base(self.path)
3986 }
3987 pub fn error(mut self) -> String {
3988 self.path.push(GetObjectResult::ERROR_FIELD.name);
3989 self.finish()
3990 }
3991 }
3992 impl GetTransactionRequest {
3993 pub const DIGEST_FIELD: &'static MessageField = &MessageField {
3994 name: "digest",
3995 json_name: "digest",
3996 number: 1i32,
3997 message_fields: None,
3998 };
3999 pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
4000 name: "read_mask",
4001 json_name: "readMask",
4002 number: 2i32,
4003 message_fields: None,
4004 };
4005 }
4006 impl MessageFields for GetTransactionRequest {
4007 const FIELDS: &'static [&'static MessageField] = &[
4008 Self::DIGEST_FIELD,
4009 Self::READ_MASK_FIELD,
4010 ];
4011 }
4012 impl GetTransactionRequest {
4013 pub fn path_builder() -> GetTransactionRequestFieldPathBuilder {
4014 GetTransactionRequestFieldPathBuilder::new()
4015 }
4016 }
4017 pub struct GetTransactionRequestFieldPathBuilder {
4018 path: Vec<&'static str>,
4019 }
4020 impl GetTransactionRequestFieldPathBuilder {
4021 #[allow(clippy::new_without_default)]
4022 pub fn new() -> Self {
4023 Self { path: Default::default() }
4024 }
4025 #[doc(hidden)]
4026 pub fn new_with_base(base: Vec<&'static str>) -> Self {
4027 Self { path: base }
4028 }
4029 pub fn finish(self) -> String {
4030 self.path.join(".")
4031 }
4032 pub fn digest(mut self) -> String {
4033 self.path.push(GetTransactionRequest::DIGEST_FIELD.name);
4034 self.finish()
4035 }
4036 pub fn read_mask(mut self) -> String {
4037 self.path.push(GetTransactionRequest::READ_MASK_FIELD.name);
4038 self.finish()
4039 }
4040 }
4041 impl GetTransactionResponse {
4042 pub const TRANSACTION_FIELD: &'static MessageField = &MessageField {
4043 name: "transaction",
4044 json_name: "transaction",
4045 number: 1i32,
4046 message_fields: Some(ExecutedTransaction::FIELDS),
4047 };
4048 }
4049 impl MessageFields for GetTransactionResponse {
4050 const FIELDS: &'static [&'static MessageField] = &[Self::TRANSACTION_FIELD];
4051 }
4052 impl GetTransactionResponse {
4053 pub fn path_builder() -> GetTransactionResponseFieldPathBuilder {
4054 GetTransactionResponseFieldPathBuilder::new()
4055 }
4056 }
4057 pub struct GetTransactionResponseFieldPathBuilder {
4058 path: Vec<&'static str>,
4059 }
4060 impl GetTransactionResponseFieldPathBuilder {
4061 #[allow(clippy::new_without_default)]
4062 pub fn new() -> Self {
4063 Self { path: Default::default() }
4064 }
4065 #[doc(hidden)]
4066 pub fn new_with_base(base: Vec<&'static str>) -> Self {
4067 Self { path: base }
4068 }
4069 pub fn finish(self) -> String {
4070 self.path.join(".")
4071 }
4072 pub fn transaction(mut self) -> ExecutedTransactionFieldPathBuilder {
4073 self.path.push(GetTransactionResponse::TRANSACTION_FIELD.name);
4074 ExecutedTransactionFieldPathBuilder::new_with_base(self.path)
4075 }
4076 }
4077 impl BatchGetTransactionsRequest {
4078 pub const DIGESTS_FIELD: &'static MessageField = &MessageField {
4079 name: "digests",
4080 json_name: "digests",
4081 number: 1i32,
4082 message_fields: None,
4083 };
4084 pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
4085 name: "read_mask",
4086 json_name: "readMask",
4087 number: 2i32,
4088 message_fields: None,
4089 };
4090 }
4091 impl MessageFields for BatchGetTransactionsRequest {
4092 const FIELDS: &'static [&'static MessageField] = &[
4093 Self::DIGESTS_FIELD,
4094 Self::READ_MASK_FIELD,
4095 ];
4096 }
4097 impl BatchGetTransactionsRequest {
4098 pub fn path_builder() -> BatchGetTransactionsRequestFieldPathBuilder {
4099 BatchGetTransactionsRequestFieldPathBuilder::new()
4100 }
4101 }
4102 pub struct BatchGetTransactionsRequestFieldPathBuilder {
4103 path: Vec<&'static str>,
4104 }
4105 impl BatchGetTransactionsRequestFieldPathBuilder {
4106 #[allow(clippy::new_without_default)]
4107 pub fn new() -> Self {
4108 Self { path: Default::default() }
4109 }
4110 #[doc(hidden)]
4111 pub fn new_with_base(base: Vec<&'static str>) -> Self {
4112 Self { path: base }
4113 }
4114 pub fn finish(self) -> String {
4115 self.path.join(".")
4116 }
4117 pub fn digests(mut self) -> String {
4118 self.path.push(BatchGetTransactionsRequest::DIGESTS_FIELD.name);
4119 self.finish()
4120 }
4121 pub fn read_mask(mut self) -> String {
4122 self.path.push(BatchGetTransactionsRequest::READ_MASK_FIELD.name);
4123 self.finish()
4124 }
4125 }
4126 impl BatchGetTransactionsResponse {
4127 pub const TRANSACTIONS_FIELD: &'static MessageField = &MessageField {
4128 name: "transactions",
4129 json_name: "transactions",
4130 number: 1i32,
4131 message_fields: Some(GetTransactionResult::FIELDS),
4132 };
4133 }
4134 impl MessageFields for BatchGetTransactionsResponse {
4135 const FIELDS: &'static [&'static MessageField] = &[Self::TRANSACTIONS_FIELD];
4136 }
4137 impl BatchGetTransactionsResponse {
4138 pub fn path_builder() -> BatchGetTransactionsResponseFieldPathBuilder {
4139 BatchGetTransactionsResponseFieldPathBuilder::new()
4140 }
4141 }
4142 pub struct BatchGetTransactionsResponseFieldPathBuilder {
4143 path: Vec<&'static str>,
4144 }
4145 impl BatchGetTransactionsResponseFieldPathBuilder {
4146 #[allow(clippy::new_without_default)]
4147 pub fn new() -> Self {
4148 Self { path: Default::default() }
4149 }
4150 #[doc(hidden)]
4151 pub fn new_with_base(base: Vec<&'static str>) -> Self {
4152 Self { path: base }
4153 }
4154 pub fn finish(self) -> String {
4155 self.path.join(".")
4156 }
4157 pub fn transactions(mut self) -> GetTransactionResultFieldPathBuilder {
4158 self.path.push(BatchGetTransactionsResponse::TRANSACTIONS_FIELD.name);
4159 GetTransactionResultFieldPathBuilder::new_with_base(self.path)
4160 }
4161 }
4162 impl GetTransactionResult {
4163 pub const TRANSACTION_FIELD: &'static MessageField = &MessageField {
4164 name: "transaction",
4165 json_name: "transaction",
4166 number: 1i32,
4167 message_fields: Some(ExecutedTransaction::FIELDS),
4168 };
4169 pub const ERROR_FIELD: &'static MessageField = &MessageField {
4170 name: "error",
4171 json_name: "error",
4172 number: 2i32,
4173 message_fields: None,
4174 };
4175 }
4176 impl MessageFields for GetTransactionResult {
4177 const FIELDS: &'static [&'static MessageField] = &[
4178 Self::TRANSACTION_FIELD,
4179 Self::ERROR_FIELD,
4180 ];
4181 }
4182 impl GetTransactionResult {
4183 pub fn path_builder() -> GetTransactionResultFieldPathBuilder {
4184 GetTransactionResultFieldPathBuilder::new()
4185 }
4186 }
4187 pub struct GetTransactionResultFieldPathBuilder {
4188 path: Vec<&'static str>,
4189 }
4190 impl GetTransactionResultFieldPathBuilder {
4191 #[allow(clippy::new_without_default)]
4192 pub fn new() -> Self {
4193 Self { path: Default::default() }
4194 }
4195 #[doc(hidden)]
4196 pub fn new_with_base(base: Vec<&'static str>) -> Self {
4197 Self { path: base }
4198 }
4199 pub fn finish(self) -> String {
4200 self.path.join(".")
4201 }
4202 pub fn transaction(mut self) -> ExecutedTransactionFieldPathBuilder {
4203 self.path.push(GetTransactionResult::TRANSACTION_FIELD.name);
4204 ExecutedTransactionFieldPathBuilder::new_with_base(self.path)
4205 }
4206 pub fn error(mut self) -> String {
4207 self.path.push(GetTransactionResult::ERROR_FIELD.name);
4208 self.finish()
4209 }
4210 }
4211 impl GetCheckpointRequest {
4212 pub const SEQUENCE_NUMBER_FIELD: &'static MessageField = &MessageField {
4213 name: "sequence_number",
4214 json_name: "sequenceNumber",
4215 number: 1i32,
4216 message_fields: None,
4217 };
4218 pub const DIGEST_FIELD: &'static MessageField = &MessageField {
4219 name: "digest",
4220 json_name: "digest",
4221 number: 2i32,
4222 message_fields: None,
4223 };
4224 pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
4225 name: "read_mask",
4226 json_name: "readMask",
4227 number: 3i32,
4228 message_fields: None,
4229 };
4230 }
4231 impl MessageFields for GetCheckpointRequest {
4232 const FIELDS: &'static [&'static MessageField] = &[
4233 Self::SEQUENCE_NUMBER_FIELD,
4234 Self::DIGEST_FIELD,
4235 Self::READ_MASK_FIELD,
4236 ];
4237 }
4238 impl GetCheckpointRequest {
4239 pub fn path_builder() -> GetCheckpointRequestFieldPathBuilder {
4240 GetCheckpointRequestFieldPathBuilder::new()
4241 }
4242 }
4243 pub struct GetCheckpointRequestFieldPathBuilder {
4244 path: Vec<&'static str>,
4245 }
4246 impl GetCheckpointRequestFieldPathBuilder {
4247 #[allow(clippy::new_without_default)]
4248 pub fn new() -> Self {
4249 Self { path: Default::default() }
4250 }
4251 #[doc(hidden)]
4252 pub fn new_with_base(base: Vec<&'static str>) -> Self {
4253 Self { path: base }
4254 }
4255 pub fn finish(self) -> String {
4256 self.path.join(".")
4257 }
4258 pub fn sequence_number(mut self) -> String {
4259 self.path.push(GetCheckpointRequest::SEQUENCE_NUMBER_FIELD.name);
4260 self.finish()
4261 }
4262 pub fn digest(mut self) -> String {
4263 self.path.push(GetCheckpointRequest::DIGEST_FIELD.name);
4264 self.finish()
4265 }
4266 pub fn read_mask(mut self) -> String {
4267 self.path.push(GetCheckpointRequest::READ_MASK_FIELD.name);
4268 self.finish()
4269 }
4270 }
4271 impl GetCheckpointResponse {
4272 pub const CHECKPOINT_FIELD: &'static MessageField = &MessageField {
4273 name: "checkpoint",
4274 json_name: "checkpoint",
4275 number: 1i32,
4276 message_fields: Some(Checkpoint::FIELDS),
4277 };
4278 }
4279 impl MessageFields for GetCheckpointResponse {
4280 const FIELDS: &'static [&'static MessageField] = &[Self::CHECKPOINT_FIELD];
4281 }
4282 impl GetCheckpointResponse {
4283 pub fn path_builder() -> GetCheckpointResponseFieldPathBuilder {
4284 GetCheckpointResponseFieldPathBuilder::new()
4285 }
4286 }
4287 pub struct GetCheckpointResponseFieldPathBuilder {
4288 path: Vec<&'static str>,
4289 }
4290 impl GetCheckpointResponseFieldPathBuilder {
4291 #[allow(clippy::new_without_default)]
4292 pub fn new() -> Self {
4293 Self { path: Default::default() }
4294 }
4295 #[doc(hidden)]
4296 pub fn new_with_base(base: Vec<&'static str>) -> Self {
4297 Self { path: base }
4298 }
4299 pub fn finish(self) -> String {
4300 self.path.join(".")
4301 }
4302 pub fn checkpoint(mut self) -> CheckpointFieldPathBuilder {
4303 self.path.push(GetCheckpointResponse::CHECKPOINT_FIELD.name);
4304 CheckpointFieldPathBuilder::new_with_base(self.path)
4305 }
4306 }
4307 impl GetEpochRequest {
4308 pub const EPOCH_FIELD: &'static MessageField = &MessageField {
4309 name: "epoch",
4310 json_name: "epoch",
4311 number: 1i32,
4312 message_fields: None,
4313 };
4314 pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
4315 name: "read_mask",
4316 json_name: "readMask",
4317 number: 2i32,
4318 message_fields: None,
4319 };
4320 }
4321 impl MessageFields for GetEpochRequest {
4322 const FIELDS: &'static [&'static MessageField] = &[
4323 Self::EPOCH_FIELD,
4324 Self::READ_MASK_FIELD,
4325 ];
4326 }
4327 impl GetEpochRequest {
4328 pub fn path_builder() -> GetEpochRequestFieldPathBuilder {
4329 GetEpochRequestFieldPathBuilder::new()
4330 }
4331 }
4332 pub struct GetEpochRequestFieldPathBuilder {
4333 path: Vec<&'static str>,
4334 }
4335 impl GetEpochRequestFieldPathBuilder {
4336 #[allow(clippy::new_without_default)]
4337 pub fn new() -> Self {
4338 Self { path: Default::default() }
4339 }
4340 #[doc(hidden)]
4341 pub fn new_with_base(base: Vec<&'static str>) -> Self {
4342 Self { path: base }
4343 }
4344 pub fn finish(self) -> String {
4345 self.path.join(".")
4346 }
4347 pub fn epoch(mut self) -> String {
4348 self.path.push(GetEpochRequest::EPOCH_FIELD.name);
4349 self.finish()
4350 }
4351 pub fn read_mask(mut self) -> String {
4352 self.path.push(GetEpochRequest::READ_MASK_FIELD.name);
4353 self.finish()
4354 }
4355 }
4356 impl GetEpochResponse {
4357 pub const EPOCH_FIELD: &'static MessageField = &MessageField {
4358 name: "epoch",
4359 json_name: "epoch",
4360 number: 1i32,
4361 message_fields: Some(Epoch::FIELDS),
4362 };
4363 }
4364 impl MessageFields for GetEpochResponse {
4365 const FIELDS: &'static [&'static MessageField] = &[Self::EPOCH_FIELD];
4366 }
4367 impl GetEpochResponse {
4368 pub fn path_builder() -> GetEpochResponseFieldPathBuilder {
4369 GetEpochResponseFieldPathBuilder::new()
4370 }
4371 }
4372 pub struct GetEpochResponseFieldPathBuilder {
4373 path: Vec<&'static str>,
4374 }
4375 impl GetEpochResponseFieldPathBuilder {
4376 #[allow(clippy::new_without_default)]
4377 pub fn new() -> Self {
4378 Self { path: Default::default() }
4379 }
4380 #[doc(hidden)]
4381 pub fn new_with_base(base: Vec<&'static str>) -> Self {
4382 Self { path: base }
4383 }
4384 pub fn finish(self) -> String {
4385 self.path.join(".")
4386 }
4387 pub fn epoch(mut self) -> EpochFieldPathBuilder {
4388 self.path.push(GetEpochResponse::EPOCH_FIELD.name);
4389 EpochFieldPathBuilder::new_with_base(self.path)
4390 }
4391 }
4392 impl ListCheckpointsRequest {
4393 pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
4394 name: "read_mask",
4395 json_name: "readMask",
4396 number: 1i32,
4397 message_fields: None,
4398 };
4399 pub const START_CHECKPOINT_FIELD: &'static MessageField = &MessageField {
4400 name: "start_checkpoint",
4401 json_name: "startCheckpoint",
4402 number: 2i32,
4403 message_fields: None,
4404 };
4405 pub const END_CHECKPOINT_FIELD: &'static MessageField = &MessageField {
4406 name: "end_checkpoint",
4407 json_name: "endCheckpoint",
4408 number: 3i32,
4409 message_fields: None,
4410 };
4411 pub const FILTER_FIELD: &'static MessageField = &MessageField {
4412 name: "filter",
4413 json_name: "filter",
4414 number: 4i32,
4415 message_fields: Some(TransactionFilter::FIELDS),
4416 };
4417 pub const OPTIONS_FIELD: &'static MessageField = &MessageField {
4418 name: "options",
4419 json_name: "options",
4420 number: 5i32,
4421 message_fields: Some(QueryOptions::FIELDS),
4422 };
4423 }
4424 impl MessageFields for ListCheckpointsRequest {
4425 const FIELDS: &'static [&'static MessageField] = &[
4426 Self::READ_MASK_FIELD,
4427 Self::START_CHECKPOINT_FIELD,
4428 Self::END_CHECKPOINT_FIELD,
4429 Self::FILTER_FIELD,
4430 Self::OPTIONS_FIELD,
4431 ];
4432 }
4433 impl ListCheckpointsRequest {
4434 pub fn path_builder() -> ListCheckpointsRequestFieldPathBuilder {
4435 ListCheckpointsRequestFieldPathBuilder::new()
4436 }
4437 }
4438 pub struct ListCheckpointsRequestFieldPathBuilder {
4439 path: Vec<&'static str>,
4440 }
4441 impl ListCheckpointsRequestFieldPathBuilder {
4442 #[allow(clippy::new_without_default)]
4443 pub fn new() -> Self {
4444 Self { path: Default::default() }
4445 }
4446 #[doc(hidden)]
4447 pub fn new_with_base(base: Vec<&'static str>) -> Self {
4448 Self { path: base }
4449 }
4450 pub fn finish(self) -> String {
4451 self.path.join(".")
4452 }
4453 pub fn read_mask(mut self) -> String {
4454 self.path.push(ListCheckpointsRequest::READ_MASK_FIELD.name);
4455 self.finish()
4456 }
4457 pub fn start_checkpoint(mut self) -> String {
4458 self.path.push(ListCheckpointsRequest::START_CHECKPOINT_FIELD.name);
4459 self.finish()
4460 }
4461 pub fn end_checkpoint(mut self) -> String {
4462 self.path.push(ListCheckpointsRequest::END_CHECKPOINT_FIELD.name);
4463 self.finish()
4464 }
4465 pub fn filter(mut self) -> TransactionFilterFieldPathBuilder {
4466 self.path.push(ListCheckpointsRequest::FILTER_FIELD.name);
4467 TransactionFilterFieldPathBuilder::new_with_base(self.path)
4468 }
4469 pub fn options(mut self) -> QueryOptionsFieldPathBuilder {
4470 self.path.push(ListCheckpointsRequest::OPTIONS_FIELD.name);
4471 QueryOptionsFieldPathBuilder::new_with_base(self.path)
4472 }
4473 }
4474 impl ListCheckpointsResponse {
4475 pub const CHECKPOINT_FIELD: &'static MessageField = &MessageField {
4476 name: "checkpoint",
4477 json_name: "checkpoint",
4478 number: 1i32,
4479 message_fields: Some(Checkpoint::FIELDS),
4480 };
4481 pub const WATERMARK_FIELD: &'static MessageField = &MessageField {
4482 name: "watermark",
4483 json_name: "watermark",
4484 number: 2i32,
4485 message_fields: Some(Watermark::FIELDS),
4486 };
4487 pub const END_FIELD: &'static MessageField = &MessageField {
4488 name: "end",
4489 json_name: "end",
4490 number: 3i32,
4491 message_fields: Some(QueryEnd::FIELDS),
4492 };
4493 }
4494 impl MessageFields for ListCheckpointsResponse {
4495 const FIELDS: &'static [&'static MessageField] = &[
4496 Self::CHECKPOINT_FIELD,
4497 Self::WATERMARK_FIELD,
4498 Self::END_FIELD,
4499 ];
4500 }
4501 impl ListCheckpointsResponse {
4502 pub fn path_builder() -> ListCheckpointsResponseFieldPathBuilder {
4503 ListCheckpointsResponseFieldPathBuilder::new()
4504 }
4505 }
4506 pub struct ListCheckpointsResponseFieldPathBuilder {
4507 path: Vec<&'static str>,
4508 }
4509 impl ListCheckpointsResponseFieldPathBuilder {
4510 #[allow(clippy::new_without_default)]
4511 pub fn new() -> Self {
4512 Self { path: Default::default() }
4513 }
4514 #[doc(hidden)]
4515 pub fn new_with_base(base: Vec<&'static str>) -> Self {
4516 Self { path: base }
4517 }
4518 pub fn finish(self) -> String {
4519 self.path.join(".")
4520 }
4521 pub fn checkpoint(mut self) -> CheckpointFieldPathBuilder {
4522 self.path.push(ListCheckpointsResponse::CHECKPOINT_FIELD.name);
4523 CheckpointFieldPathBuilder::new_with_base(self.path)
4524 }
4525 pub fn watermark(mut self) -> WatermarkFieldPathBuilder {
4526 self.path.push(ListCheckpointsResponse::WATERMARK_FIELD.name);
4527 WatermarkFieldPathBuilder::new_with_base(self.path)
4528 }
4529 pub fn end(mut self) -> QueryEndFieldPathBuilder {
4530 self.path.push(ListCheckpointsResponse::END_FIELD.name);
4531 QueryEndFieldPathBuilder::new_with_base(self.path)
4532 }
4533 }
4534 impl ListTransactionsRequest {
4535 pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
4536 name: "read_mask",
4537 json_name: "readMask",
4538 number: 1i32,
4539 message_fields: None,
4540 };
4541 pub const START_CHECKPOINT_FIELD: &'static MessageField = &MessageField {
4542 name: "start_checkpoint",
4543 json_name: "startCheckpoint",
4544 number: 2i32,
4545 message_fields: None,
4546 };
4547 pub const END_CHECKPOINT_FIELD: &'static MessageField = &MessageField {
4548 name: "end_checkpoint",
4549 json_name: "endCheckpoint",
4550 number: 3i32,
4551 message_fields: None,
4552 };
4553 pub const FILTER_FIELD: &'static MessageField = &MessageField {
4554 name: "filter",
4555 json_name: "filter",
4556 number: 4i32,
4557 message_fields: Some(TransactionFilter::FIELDS),
4558 };
4559 pub const OPTIONS_FIELD: &'static MessageField = &MessageField {
4560 name: "options",
4561 json_name: "options",
4562 number: 5i32,
4563 message_fields: Some(QueryOptions::FIELDS),
4564 };
4565 }
4566 impl MessageFields for ListTransactionsRequest {
4567 const FIELDS: &'static [&'static MessageField] = &[
4568 Self::READ_MASK_FIELD,
4569 Self::START_CHECKPOINT_FIELD,
4570 Self::END_CHECKPOINT_FIELD,
4571 Self::FILTER_FIELD,
4572 Self::OPTIONS_FIELD,
4573 ];
4574 }
4575 impl ListTransactionsRequest {
4576 pub fn path_builder() -> ListTransactionsRequestFieldPathBuilder {
4577 ListTransactionsRequestFieldPathBuilder::new()
4578 }
4579 }
4580 pub struct ListTransactionsRequestFieldPathBuilder {
4581 path: Vec<&'static str>,
4582 }
4583 impl ListTransactionsRequestFieldPathBuilder {
4584 #[allow(clippy::new_without_default)]
4585 pub fn new() -> Self {
4586 Self { path: Default::default() }
4587 }
4588 #[doc(hidden)]
4589 pub fn new_with_base(base: Vec<&'static str>) -> Self {
4590 Self { path: base }
4591 }
4592 pub fn finish(self) -> String {
4593 self.path.join(".")
4594 }
4595 pub fn read_mask(mut self) -> String {
4596 self.path.push(ListTransactionsRequest::READ_MASK_FIELD.name);
4597 self.finish()
4598 }
4599 pub fn start_checkpoint(mut self) -> String {
4600 self.path.push(ListTransactionsRequest::START_CHECKPOINT_FIELD.name);
4601 self.finish()
4602 }
4603 pub fn end_checkpoint(mut self) -> String {
4604 self.path.push(ListTransactionsRequest::END_CHECKPOINT_FIELD.name);
4605 self.finish()
4606 }
4607 pub fn filter(mut self) -> TransactionFilterFieldPathBuilder {
4608 self.path.push(ListTransactionsRequest::FILTER_FIELD.name);
4609 TransactionFilterFieldPathBuilder::new_with_base(self.path)
4610 }
4611 pub fn options(mut self) -> QueryOptionsFieldPathBuilder {
4612 self.path.push(ListTransactionsRequest::OPTIONS_FIELD.name);
4613 QueryOptionsFieldPathBuilder::new_with_base(self.path)
4614 }
4615 }
4616 impl ListTransactionsResponse {
4617 pub const TRANSACTION_FIELD: &'static MessageField = &MessageField {
4618 name: "transaction",
4619 json_name: "transaction",
4620 number: 1i32,
4621 message_fields: Some(ExecutedTransaction::FIELDS),
4622 };
4623 pub const WATERMARK_FIELD: &'static MessageField = &MessageField {
4624 name: "watermark",
4625 json_name: "watermark",
4626 number: 2i32,
4627 message_fields: Some(Watermark::FIELDS),
4628 };
4629 pub const END_FIELD: &'static MessageField = &MessageField {
4630 name: "end",
4631 json_name: "end",
4632 number: 3i32,
4633 message_fields: Some(QueryEnd::FIELDS),
4634 };
4635 }
4636 impl MessageFields for ListTransactionsResponse {
4637 const FIELDS: &'static [&'static MessageField] = &[
4638 Self::TRANSACTION_FIELD,
4639 Self::WATERMARK_FIELD,
4640 Self::END_FIELD,
4641 ];
4642 }
4643 impl ListTransactionsResponse {
4644 pub fn path_builder() -> ListTransactionsResponseFieldPathBuilder {
4645 ListTransactionsResponseFieldPathBuilder::new()
4646 }
4647 }
4648 pub struct ListTransactionsResponseFieldPathBuilder {
4649 path: Vec<&'static str>,
4650 }
4651 impl ListTransactionsResponseFieldPathBuilder {
4652 #[allow(clippy::new_without_default)]
4653 pub fn new() -> Self {
4654 Self { path: Default::default() }
4655 }
4656 #[doc(hidden)]
4657 pub fn new_with_base(base: Vec<&'static str>) -> Self {
4658 Self { path: base }
4659 }
4660 pub fn finish(self) -> String {
4661 self.path.join(".")
4662 }
4663 pub fn transaction(mut self) -> ExecutedTransactionFieldPathBuilder {
4664 self.path.push(ListTransactionsResponse::TRANSACTION_FIELD.name);
4665 ExecutedTransactionFieldPathBuilder::new_with_base(self.path)
4666 }
4667 pub fn watermark(mut self) -> WatermarkFieldPathBuilder {
4668 self.path.push(ListTransactionsResponse::WATERMARK_FIELD.name);
4669 WatermarkFieldPathBuilder::new_with_base(self.path)
4670 }
4671 pub fn end(mut self) -> QueryEndFieldPathBuilder {
4672 self.path.push(ListTransactionsResponse::END_FIELD.name);
4673 QueryEndFieldPathBuilder::new_with_base(self.path)
4674 }
4675 }
4676 impl ListEventsRequest {
4677 pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
4678 name: "read_mask",
4679 json_name: "readMask",
4680 number: 1i32,
4681 message_fields: None,
4682 };
4683 pub const START_CHECKPOINT_FIELD: &'static MessageField = &MessageField {
4684 name: "start_checkpoint",
4685 json_name: "startCheckpoint",
4686 number: 2i32,
4687 message_fields: None,
4688 };
4689 pub const END_CHECKPOINT_FIELD: &'static MessageField = &MessageField {
4690 name: "end_checkpoint",
4691 json_name: "endCheckpoint",
4692 number: 3i32,
4693 message_fields: None,
4694 };
4695 pub const FILTER_FIELD: &'static MessageField = &MessageField {
4696 name: "filter",
4697 json_name: "filter",
4698 number: 4i32,
4699 message_fields: Some(EventFilter::FIELDS),
4700 };
4701 pub const OPTIONS_FIELD: &'static MessageField = &MessageField {
4702 name: "options",
4703 json_name: "options",
4704 number: 5i32,
4705 message_fields: Some(QueryOptions::FIELDS),
4706 };
4707 }
4708 impl MessageFields for ListEventsRequest {
4709 const FIELDS: &'static [&'static MessageField] = &[
4710 Self::READ_MASK_FIELD,
4711 Self::START_CHECKPOINT_FIELD,
4712 Self::END_CHECKPOINT_FIELD,
4713 Self::FILTER_FIELD,
4714 Self::OPTIONS_FIELD,
4715 ];
4716 }
4717 impl ListEventsRequest {
4718 pub fn path_builder() -> ListEventsRequestFieldPathBuilder {
4719 ListEventsRequestFieldPathBuilder::new()
4720 }
4721 }
4722 pub struct ListEventsRequestFieldPathBuilder {
4723 path: Vec<&'static str>,
4724 }
4725 impl ListEventsRequestFieldPathBuilder {
4726 #[allow(clippy::new_without_default)]
4727 pub fn new() -> Self {
4728 Self { path: Default::default() }
4729 }
4730 #[doc(hidden)]
4731 pub fn new_with_base(base: Vec<&'static str>) -> Self {
4732 Self { path: base }
4733 }
4734 pub fn finish(self) -> String {
4735 self.path.join(".")
4736 }
4737 pub fn read_mask(mut self) -> String {
4738 self.path.push(ListEventsRequest::READ_MASK_FIELD.name);
4739 self.finish()
4740 }
4741 pub fn start_checkpoint(mut self) -> String {
4742 self.path.push(ListEventsRequest::START_CHECKPOINT_FIELD.name);
4743 self.finish()
4744 }
4745 pub fn end_checkpoint(mut self) -> String {
4746 self.path.push(ListEventsRequest::END_CHECKPOINT_FIELD.name);
4747 self.finish()
4748 }
4749 pub fn filter(mut self) -> EventFilterFieldPathBuilder {
4750 self.path.push(ListEventsRequest::FILTER_FIELD.name);
4751 EventFilterFieldPathBuilder::new_with_base(self.path)
4752 }
4753 pub fn options(mut self) -> QueryOptionsFieldPathBuilder {
4754 self.path.push(ListEventsRequest::OPTIONS_FIELD.name);
4755 QueryOptionsFieldPathBuilder::new_with_base(self.path)
4756 }
4757 }
4758 impl ListEventsResponse {
4759 pub const EVENT_FIELD: &'static MessageField = &MessageField {
4760 name: "event",
4761 json_name: "event",
4762 number: 1i32,
4763 message_fields: Some(Event::FIELDS),
4764 };
4765 pub const WATERMARK_FIELD: &'static MessageField = &MessageField {
4766 name: "watermark",
4767 json_name: "watermark",
4768 number: 2i32,
4769 message_fields: Some(Watermark::FIELDS),
4770 };
4771 pub const END_FIELD: &'static MessageField = &MessageField {
4772 name: "end",
4773 json_name: "end",
4774 number: 3i32,
4775 message_fields: Some(QueryEnd::FIELDS),
4776 };
4777 }
4778 impl MessageFields for ListEventsResponse {
4779 const FIELDS: &'static [&'static MessageField] = &[
4780 Self::EVENT_FIELD,
4781 Self::WATERMARK_FIELD,
4782 Self::END_FIELD,
4783 ];
4784 }
4785 impl ListEventsResponse {
4786 pub fn path_builder() -> ListEventsResponseFieldPathBuilder {
4787 ListEventsResponseFieldPathBuilder::new()
4788 }
4789 }
4790 pub struct ListEventsResponseFieldPathBuilder {
4791 path: Vec<&'static str>,
4792 }
4793 impl ListEventsResponseFieldPathBuilder {
4794 #[allow(clippy::new_without_default)]
4795 pub fn new() -> Self {
4796 Self { path: Default::default() }
4797 }
4798 #[doc(hidden)]
4799 pub fn new_with_base(base: Vec<&'static str>) -> Self {
4800 Self { path: base }
4801 }
4802 pub fn finish(self) -> String {
4803 self.path.join(".")
4804 }
4805 pub fn event(mut self) -> EventFieldPathBuilder {
4806 self.path.push(ListEventsResponse::EVENT_FIELD.name);
4807 EventFieldPathBuilder::new_with_base(self.path)
4808 }
4809 pub fn watermark(mut self) -> WatermarkFieldPathBuilder {
4810 self.path.push(ListEventsResponse::WATERMARK_FIELD.name);
4811 WatermarkFieldPathBuilder::new_with_base(self.path)
4812 }
4813 pub fn end(mut self) -> QueryEndFieldPathBuilder {
4814 self.path.push(ListEventsResponse::END_FIELD.name);
4815 QueryEndFieldPathBuilder::new_with_base(self.path)
4816 }
4817 }
4818 impl Package {
4819 pub const STORAGE_ID_FIELD: &'static MessageField = &MessageField {
4820 name: "storage_id",
4821 json_name: "storageId",
4822 number: 1i32,
4823 message_fields: None,
4824 };
4825 pub const ORIGINAL_ID_FIELD: &'static MessageField = &MessageField {
4826 name: "original_id",
4827 json_name: "originalId",
4828 number: 2i32,
4829 message_fields: None,
4830 };
4831 pub const VERSION_FIELD: &'static MessageField = &MessageField {
4832 name: "version",
4833 json_name: "version",
4834 number: 3i32,
4835 message_fields: None,
4836 };
4837 pub const MODULES_FIELD: &'static MessageField = &MessageField {
4838 name: "modules",
4839 json_name: "modules",
4840 number: 4i32,
4841 message_fields: Some(Module::FIELDS),
4842 };
4843 pub const TYPE_ORIGINS_FIELD: &'static MessageField = &MessageField {
4844 name: "type_origins",
4845 json_name: "typeOrigins",
4846 number: 5i32,
4847 message_fields: Some(TypeOrigin::FIELDS),
4848 };
4849 pub const LINKAGE_FIELD: &'static MessageField = &MessageField {
4850 name: "linkage",
4851 json_name: "linkage",
4852 number: 6i32,
4853 message_fields: Some(Linkage::FIELDS),
4854 };
4855 }
4856 impl MessageFields for Package {
4857 const FIELDS: &'static [&'static MessageField] = &[
4858 Self::STORAGE_ID_FIELD,
4859 Self::ORIGINAL_ID_FIELD,
4860 Self::VERSION_FIELD,
4861 Self::MODULES_FIELD,
4862 Self::TYPE_ORIGINS_FIELD,
4863 Self::LINKAGE_FIELD,
4864 ];
4865 }
4866 impl Package {
4867 pub fn path_builder() -> PackageFieldPathBuilder {
4868 PackageFieldPathBuilder::new()
4869 }
4870 }
4871 pub struct PackageFieldPathBuilder {
4872 path: Vec<&'static str>,
4873 }
4874 impl PackageFieldPathBuilder {
4875 #[allow(clippy::new_without_default)]
4876 pub fn new() -> Self {
4877 Self { path: Default::default() }
4878 }
4879 #[doc(hidden)]
4880 pub fn new_with_base(base: Vec<&'static str>) -> Self {
4881 Self { path: base }
4882 }
4883 pub fn finish(self) -> String {
4884 self.path.join(".")
4885 }
4886 pub fn storage_id(mut self) -> String {
4887 self.path.push(Package::STORAGE_ID_FIELD.name);
4888 self.finish()
4889 }
4890 pub fn original_id(mut self) -> String {
4891 self.path.push(Package::ORIGINAL_ID_FIELD.name);
4892 self.finish()
4893 }
4894 pub fn version(mut self) -> String {
4895 self.path.push(Package::VERSION_FIELD.name);
4896 self.finish()
4897 }
4898 pub fn modules(mut self) -> ModuleFieldPathBuilder {
4899 self.path.push(Package::MODULES_FIELD.name);
4900 ModuleFieldPathBuilder::new_with_base(self.path)
4901 }
4902 pub fn type_origins(mut self) -> TypeOriginFieldPathBuilder {
4903 self.path.push(Package::TYPE_ORIGINS_FIELD.name);
4904 TypeOriginFieldPathBuilder::new_with_base(self.path)
4905 }
4906 pub fn linkage(mut self) -> LinkageFieldPathBuilder {
4907 self.path.push(Package::LINKAGE_FIELD.name);
4908 LinkageFieldPathBuilder::new_with_base(self.path)
4909 }
4910 }
4911 impl Module {
4912 pub const NAME_FIELD: &'static MessageField = &MessageField {
4913 name: "name",
4914 json_name: "name",
4915 number: 1i32,
4916 message_fields: None,
4917 };
4918 pub const CONTENTS_FIELD: &'static MessageField = &MessageField {
4919 name: "contents",
4920 json_name: "contents",
4921 number: 2i32,
4922 message_fields: None,
4923 };
4924 pub const DATATYPES_FIELD: &'static MessageField = &MessageField {
4925 name: "datatypes",
4926 json_name: "datatypes",
4927 number: 3i32,
4928 message_fields: Some(DatatypeDescriptor::FIELDS),
4929 };
4930 pub const FUNCTIONS_FIELD: &'static MessageField = &MessageField {
4931 name: "functions",
4932 json_name: "functions",
4933 number: 4i32,
4934 message_fields: Some(FunctionDescriptor::FIELDS),
4935 };
4936 }
4937 impl MessageFields for Module {
4938 const FIELDS: &'static [&'static MessageField] = &[
4939 Self::NAME_FIELD,
4940 Self::CONTENTS_FIELD,
4941 Self::DATATYPES_FIELD,
4942 Self::FUNCTIONS_FIELD,
4943 ];
4944 }
4945 impl Module {
4946 pub fn path_builder() -> ModuleFieldPathBuilder {
4947 ModuleFieldPathBuilder::new()
4948 }
4949 }
4950 pub struct ModuleFieldPathBuilder {
4951 path: Vec<&'static str>,
4952 }
4953 impl ModuleFieldPathBuilder {
4954 #[allow(clippy::new_without_default)]
4955 pub fn new() -> Self {
4956 Self { path: Default::default() }
4957 }
4958 #[doc(hidden)]
4959 pub fn new_with_base(base: Vec<&'static str>) -> Self {
4960 Self { path: base }
4961 }
4962 pub fn finish(self) -> String {
4963 self.path.join(".")
4964 }
4965 pub fn name(mut self) -> String {
4966 self.path.push(Module::NAME_FIELD.name);
4967 self.finish()
4968 }
4969 pub fn contents(mut self) -> String {
4970 self.path.push(Module::CONTENTS_FIELD.name);
4971 self.finish()
4972 }
4973 pub fn datatypes(mut self) -> DatatypeDescriptorFieldPathBuilder {
4974 self.path.push(Module::DATATYPES_FIELD.name);
4975 DatatypeDescriptorFieldPathBuilder::new_with_base(self.path)
4976 }
4977 pub fn functions(mut self) -> FunctionDescriptorFieldPathBuilder {
4978 self.path.push(Module::FUNCTIONS_FIELD.name);
4979 FunctionDescriptorFieldPathBuilder::new_with_base(self.path)
4980 }
4981 }
4982 impl DatatypeDescriptor {
4983 pub const TYPE_NAME_FIELD: &'static MessageField = &MessageField {
4984 name: "type_name",
4985 json_name: "typeName",
4986 number: 1i32,
4987 message_fields: None,
4988 };
4989 pub const DEFINING_ID_FIELD: &'static MessageField = &MessageField {
4990 name: "defining_id",
4991 json_name: "definingId",
4992 number: 2i32,
4993 message_fields: None,
4994 };
4995 pub const MODULE_FIELD: &'static MessageField = &MessageField {
4996 name: "module",
4997 json_name: "module",
4998 number: 3i32,
4999 message_fields: None,
5000 };
5001 pub const NAME_FIELD: &'static MessageField = &MessageField {
5002 name: "name",
5003 json_name: "name",
5004 number: 4i32,
5005 message_fields: None,
5006 };
5007 pub const ABILITIES_FIELD: &'static MessageField = &MessageField {
5008 name: "abilities",
5009 json_name: "abilities",
5010 number: 5i32,
5011 message_fields: None,
5012 };
5013 pub const TYPE_PARAMETERS_FIELD: &'static MessageField = &MessageField {
5014 name: "type_parameters",
5015 json_name: "typeParameters",
5016 number: 6i32,
5017 message_fields: Some(TypeParameter::FIELDS),
5018 };
5019 pub const KIND_FIELD: &'static MessageField = &MessageField {
5020 name: "kind",
5021 json_name: "kind",
5022 number: 7i32,
5023 message_fields: None,
5024 };
5025 pub const FIELDS_FIELD: &'static MessageField = &MessageField {
5026 name: "fields",
5027 json_name: "fields",
5028 number: 8i32,
5029 message_fields: Some(FieldDescriptor::FIELDS),
5030 };
5031 pub const VARIANTS_FIELD: &'static MessageField = &MessageField {
5032 name: "variants",
5033 json_name: "variants",
5034 number: 9i32,
5035 message_fields: Some(VariantDescriptor::FIELDS),
5036 };
5037 }
5038 impl MessageFields for DatatypeDescriptor {
5039 const FIELDS: &'static [&'static MessageField] = &[
5040 Self::TYPE_NAME_FIELD,
5041 Self::DEFINING_ID_FIELD,
5042 Self::MODULE_FIELD,
5043 Self::NAME_FIELD,
5044 Self::ABILITIES_FIELD,
5045 Self::TYPE_PARAMETERS_FIELD,
5046 Self::KIND_FIELD,
5047 Self::FIELDS_FIELD,
5048 Self::VARIANTS_FIELD,
5049 ];
5050 }
5051 impl DatatypeDescriptor {
5052 pub fn path_builder() -> DatatypeDescriptorFieldPathBuilder {
5053 DatatypeDescriptorFieldPathBuilder::new()
5054 }
5055 }
5056 pub struct DatatypeDescriptorFieldPathBuilder {
5057 path: Vec<&'static str>,
5058 }
5059 impl DatatypeDescriptorFieldPathBuilder {
5060 #[allow(clippy::new_without_default)]
5061 pub fn new() -> Self {
5062 Self { path: Default::default() }
5063 }
5064 #[doc(hidden)]
5065 pub fn new_with_base(base: Vec<&'static str>) -> Self {
5066 Self { path: base }
5067 }
5068 pub fn finish(self) -> String {
5069 self.path.join(".")
5070 }
5071 pub fn type_name(mut self) -> String {
5072 self.path.push(DatatypeDescriptor::TYPE_NAME_FIELD.name);
5073 self.finish()
5074 }
5075 pub fn defining_id(mut self) -> String {
5076 self.path.push(DatatypeDescriptor::DEFINING_ID_FIELD.name);
5077 self.finish()
5078 }
5079 pub fn module(mut self) -> String {
5080 self.path.push(DatatypeDescriptor::MODULE_FIELD.name);
5081 self.finish()
5082 }
5083 pub fn name(mut self) -> String {
5084 self.path.push(DatatypeDescriptor::NAME_FIELD.name);
5085 self.finish()
5086 }
5087 pub fn abilities(mut self) -> String {
5088 self.path.push(DatatypeDescriptor::ABILITIES_FIELD.name);
5089 self.finish()
5090 }
5091 pub fn type_parameters(mut self) -> TypeParameterFieldPathBuilder {
5092 self.path.push(DatatypeDescriptor::TYPE_PARAMETERS_FIELD.name);
5093 TypeParameterFieldPathBuilder::new_with_base(self.path)
5094 }
5095 pub fn kind(mut self) -> String {
5096 self.path.push(DatatypeDescriptor::KIND_FIELD.name);
5097 self.finish()
5098 }
5099 pub fn fields(mut self) -> FieldDescriptorFieldPathBuilder {
5100 self.path.push(DatatypeDescriptor::FIELDS_FIELD.name);
5101 FieldDescriptorFieldPathBuilder::new_with_base(self.path)
5102 }
5103 pub fn variants(mut self) -> VariantDescriptorFieldPathBuilder {
5104 self.path.push(DatatypeDescriptor::VARIANTS_FIELD.name);
5105 VariantDescriptorFieldPathBuilder::new_with_base(self.path)
5106 }
5107 }
5108 impl TypeParameter {
5109 pub const CONSTRAINTS_FIELD: &'static MessageField = &MessageField {
5110 name: "constraints",
5111 json_name: "constraints",
5112 number: 1i32,
5113 message_fields: None,
5114 };
5115 pub const IS_PHANTOM_FIELD: &'static MessageField = &MessageField {
5116 name: "is_phantom",
5117 json_name: "isPhantom",
5118 number: 2i32,
5119 message_fields: None,
5120 };
5121 }
5122 impl MessageFields for TypeParameter {
5123 const FIELDS: &'static [&'static MessageField] = &[
5124 Self::CONSTRAINTS_FIELD,
5125 Self::IS_PHANTOM_FIELD,
5126 ];
5127 }
5128 impl TypeParameter {
5129 pub fn path_builder() -> TypeParameterFieldPathBuilder {
5130 TypeParameterFieldPathBuilder::new()
5131 }
5132 }
5133 pub struct TypeParameterFieldPathBuilder {
5134 path: Vec<&'static str>,
5135 }
5136 impl TypeParameterFieldPathBuilder {
5137 #[allow(clippy::new_without_default)]
5138 pub fn new() -> Self {
5139 Self { path: Default::default() }
5140 }
5141 #[doc(hidden)]
5142 pub fn new_with_base(base: Vec<&'static str>) -> Self {
5143 Self { path: base }
5144 }
5145 pub fn finish(self) -> String {
5146 self.path.join(".")
5147 }
5148 pub fn constraints(mut self) -> String {
5149 self.path.push(TypeParameter::CONSTRAINTS_FIELD.name);
5150 self.finish()
5151 }
5152 pub fn is_phantom(mut self) -> String {
5153 self.path.push(TypeParameter::IS_PHANTOM_FIELD.name);
5154 self.finish()
5155 }
5156 }
5157 impl FieldDescriptor {
5158 pub const NAME_FIELD: &'static MessageField = &MessageField {
5159 name: "name",
5160 json_name: "name",
5161 number: 1i32,
5162 message_fields: None,
5163 };
5164 pub const POSITION_FIELD: &'static MessageField = &MessageField {
5165 name: "position",
5166 json_name: "position",
5167 number: 2i32,
5168 message_fields: None,
5169 };
5170 pub const TYPE_FIELD: &'static MessageField = &MessageField {
5171 name: "type",
5172 json_name: "type",
5173 number: 3i32,
5174 message_fields: Some(OpenSignatureBody::FIELDS),
5175 };
5176 }
5177 impl MessageFields for FieldDescriptor {
5178 const FIELDS: &'static [&'static MessageField] = &[
5179 Self::NAME_FIELD,
5180 Self::POSITION_FIELD,
5181 Self::TYPE_FIELD,
5182 ];
5183 }
5184 impl FieldDescriptor {
5185 pub fn path_builder() -> FieldDescriptorFieldPathBuilder {
5186 FieldDescriptorFieldPathBuilder::new()
5187 }
5188 }
5189 pub struct FieldDescriptorFieldPathBuilder {
5190 path: Vec<&'static str>,
5191 }
5192 impl FieldDescriptorFieldPathBuilder {
5193 #[allow(clippy::new_without_default)]
5194 pub fn new() -> Self {
5195 Self { path: Default::default() }
5196 }
5197 #[doc(hidden)]
5198 pub fn new_with_base(base: Vec<&'static str>) -> Self {
5199 Self { path: base }
5200 }
5201 pub fn finish(self) -> String {
5202 self.path.join(".")
5203 }
5204 pub fn name(mut self) -> String {
5205 self.path.push(FieldDescriptor::NAME_FIELD.name);
5206 self.finish()
5207 }
5208 pub fn position(mut self) -> String {
5209 self.path.push(FieldDescriptor::POSITION_FIELD.name);
5210 self.finish()
5211 }
5212 pub fn r#type(mut self) -> OpenSignatureBodyFieldPathBuilder {
5213 self.path.push(FieldDescriptor::TYPE_FIELD.name);
5214 OpenSignatureBodyFieldPathBuilder::new_with_base(self.path)
5215 }
5216 }
5217 impl VariantDescriptor {
5218 pub const NAME_FIELD: &'static MessageField = &MessageField {
5219 name: "name",
5220 json_name: "name",
5221 number: 1i32,
5222 message_fields: None,
5223 };
5224 pub const POSITION_FIELD: &'static MessageField = &MessageField {
5225 name: "position",
5226 json_name: "position",
5227 number: 2i32,
5228 message_fields: None,
5229 };
5230 pub const FIELDS_FIELD: &'static MessageField = &MessageField {
5231 name: "fields",
5232 json_name: "fields",
5233 number: 3i32,
5234 message_fields: Some(FieldDescriptor::FIELDS),
5235 };
5236 }
5237 impl MessageFields for VariantDescriptor {
5238 const FIELDS: &'static [&'static MessageField] = &[
5239 Self::NAME_FIELD,
5240 Self::POSITION_FIELD,
5241 Self::FIELDS_FIELD,
5242 ];
5243 }
5244 impl VariantDescriptor {
5245 pub fn path_builder() -> VariantDescriptorFieldPathBuilder {
5246 VariantDescriptorFieldPathBuilder::new()
5247 }
5248 }
5249 pub struct VariantDescriptorFieldPathBuilder {
5250 path: Vec<&'static str>,
5251 }
5252 impl VariantDescriptorFieldPathBuilder {
5253 #[allow(clippy::new_without_default)]
5254 pub fn new() -> Self {
5255 Self { path: Default::default() }
5256 }
5257 #[doc(hidden)]
5258 pub fn new_with_base(base: Vec<&'static str>) -> Self {
5259 Self { path: base }
5260 }
5261 pub fn finish(self) -> String {
5262 self.path.join(".")
5263 }
5264 pub fn name(mut self) -> String {
5265 self.path.push(VariantDescriptor::NAME_FIELD.name);
5266 self.finish()
5267 }
5268 pub fn position(mut self) -> String {
5269 self.path.push(VariantDescriptor::POSITION_FIELD.name);
5270 self.finish()
5271 }
5272 pub fn fields(mut self) -> FieldDescriptorFieldPathBuilder {
5273 self.path.push(VariantDescriptor::FIELDS_FIELD.name);
5274 FieldDescriptorFieldPathBuilder::new_with_base(self.path)
5275 }
5276 }
5277 impl OpenSignatureBody {
5278 pub const TYPE_FIELD: &'static MessageField = &MessageField {
5279 name: "type",
5280 json_name: "type",
5281 number: 1i32,
5282 message_fields: None,
5283 };
5284 pub const TYPE_NAME_FIELD: &'static MessageField = &MessageField {
5285 name: "type_name",
5286 json_name: "typeName",
5287 number: 2i32,
5288 message_fields: None,
5289 };
5290 pub const TYPE_PARAMETER_INSTANTIATION_FIELD: &'static MessageField = &MessageField {
5291 name: "type_parameter_instantiation",
5292 json_name: "typeParameterInstantiation",
5293 number: 3i32,
5294 message_fields: None,
5295 };
5296 pub const TYPE_PARAMETER_FIELD: &'static MessageField = &MessageField {
5297 name: "type_parameter",
5298 json_name: "typeParameter",
5299 number: 4i32,
5300 message_fields: None,
5301 };
5302 }
5303 impl MessageFields for OpenSignatureBody {
5304 const FIELDS: &'static [&'static MessageField] = &[
5305 Self::TYPE_FIELD,
5306 Self::TYPE_NAME_FIELD,
5307 Self::TYPE_PARAMETER_INSTANTIATION_FIELD,
5308 Self::TYPE_PARAMETER_FIELD,
5309 ];
5310 }
5311 impl OpenSignatureBody {
5312 pub fn path_builder() -> OpenSignatureBodyFieldPathBuilder {
5313 OpenSignatureBodyFieldPathBuilder::new()
5314 }
5315 }
5316 pub struct OpenSignatureBodyFieldPathBuilder {
5317 path: Vec<&'static str>,
5318 }
5319 impl OpenSignatureBodyFieldPathBuilder {
5320 #[allow(clippy::new_without_default)]
5321 pub fn new() -> Self {
5322 Self { path: Default::default() }
5323 }
5324 #[doc(hidden)]
5325 pub fn new_with_base(base: Vec<&'static str>) -> Self {
5326 Self { path: base }
5327 }
5328 pub fn finish(self) -> String {
5329 self.path.join(".")
5330 }
5331 pub fn r#type(mut self) -> String {
5332 self.path.push(OpenSignatureBody::TYPE_FIELD.name);
5333 self.finish()
5334 }
5335 pub fn type_name(mut self) -> String {
5336 self.path.push(OpenSignatureBody::TYPE_NAME_FIELD.name);
5337 self.finish()
5338 }
5339 pub fn type_parameter_instantiation(mut self) -> String {
5340 self.path.push(OpenSignatureBody::TYPE_PARAMETER_INSTANTIATION_FIELD.name);
5341 self.finish()
5342 }
5343 pub fn type_parameter(mut self) -> String {
5344 self.path.push(OpenSignatureBody::TYPE_PARAMETER_FIELD.name);
5345 self.finish()
5346 }
5347 }
5348 impl FunctionDescriptor {
5349 pub const NAME_FIELD: &'static MessageField = &MessageField {
5350 name: "name",
5351 json_name: "name",
5352 number: 1i32,
5353 message_fields: None,
5354 };
5355 pub const VISIBILITY_FIELD: &'static MessageField = &MessageField {
5356 name: "visibility",
5357 json_name: "visibility",
5358 number: 5i32,
5359 message_fields: None,
5360 };
5361 pub const IS_ENTRY_FIELD: &'static MessageField = &MessageField {
5362 name: "is_entry",
5363 json_name: "isEntry",
5364 number: 6i32,
5365 message_fields: None,
5366 };
5367 pub const TYPE_PARAMETERS_FIELD: &'static MessageField = &MessageField {
5368 name: "type_parameters",
5369 json_name: "typeParameters",
5370 number: 7i32,
5371 message_fields: Some(TypeParameter::FIELDS),
5372 };
5373 pub const PARAMETERS_FIELD: &'static MessageField = &MessageField {
5374 name: "parameters",
5375 json_name: "parameters",
5376 number: 8i32,
5377 message_fields: Some(OpenSignature::FIELDS),
5378 };
5379 pub const RETURNS_FIELD: &'static MessageField = &MessageField {
5380 name: "returns",
5381 json_name: "returns",
5382 number: 9i32,
5383 message_fields: Some(OpenSignature::FIELDS),
5384 };
5385 }
5386 impl MessageFields for FunctionDescriptor {
5387 const FIELDS: &'static [&'static MessageField] = &[
5388 Self::NAME_FIELD,
5389 Self::VISIBILITY_FIELD,
5390 Self::IS_ENTRY_FIELD,
5391 Self::TYPE_PARAMETERS_FIELD,
5392 Self::PARAMETERS_FIELD,
5393 Self::RETURNS_FIELD,
5394 ];
5395 }
5396 impl FunctionDescriptor {
5397 pub fn path_builder() -> FunctionDescriptorFieldPathBuilder {
5398 FunctionDescriptorFieldPathBuilder::new()
5399 }
5400 }
5401 pub struct FunctionDescriptorFieldPathBuilder {
5402 path: Vec<&'static str>,
5403 }
5404 impl FunctionDescriptorFieldPathBuilder {
5405 #[allow(clippy::new_without_default)]
5406 pub fn new() -> Self {
5407 Self { path: Default::default() }
5408 }
5409 #[doc(hidden)]
5410 pub fn new_with_base(base: Vec<&'static str>) -> Self {
5411 Self { path: base }
5412 }
5413 pub fn finish(self) -> String {
5414 self.path.join(".")
5415 }
5416 pub fn name(mut self) -> String {
5417 self.path.push(FunctionDescriptor::NAME_FIELD.name);
5418 self.finish()
5419 }
5420 pub fn visibility(mut self) -> String {
5421 self.path.push(FunctionDescriptor::VISIBILITY_FIELD.name);
5422 self.finish()
5423 }
5424 pub fn is_entry(mut self) -> String {
5425 self.path.push(FunctionDescriptor::IS_ENTRY_FIELD.name);
5426 self.finish()
5427 }
5428 pub fn type_parameters(mut self) -> TypeParameterFieldPathBuilder {
5429 self.path.push(FunctionDescriptor::TYPE_PARAMETERS_FIELD.name);
5430 TypeParameterFieldPathBuilder::new_with_base(self.path)
5431 }
5432 pub fn parameters(mut self) -> OpenSignatureFieldPathBuilder {
5433 self.path.push(FunctionDescriptor::PARAMETERS_FIELD.name);
5434 OpenSignatureFieldPathBuilder::new_with_base(self.path)
5435 }
5436 pub fn returns(mut self) -> OpenSignatureFieldPathBuilder {
5437 self.path.push(FunctionDescriptor::RETURNS_FIELD.name);
5438 OpenSignatureFieldPathBuilder::new_with_base(self.path)
5439 }
5440 }
5441 impl OpenSignature {
5442 pub const REFERENCE_FIELD: &'static MessageField = &MessageField {
5443 name: "reference",
5444 json_name: "reference",
5445 number: 1i32,
5446 message_fields: None,
5447 };
5448 pub const BODY_FIELD: &'static MessageField = &MessageField {
5449 name: "body",
5450 json_name: "body",
5451 number: 2i32,
5452 message_fields: Some(OpenSignatureBody::FIELDS),
5453 };
5454 }
5455 impl MessageFields for OpenSignature {
5456 const FIELDS: &'static [&'static MessageField] = &[
5457 Self::REFERENCE_FIELD,
5458 Self::BODY_FIELD,
5459 ];
5460 }
5461 impl OpenSignature {
5462 pub fn path_builder() -> OpenSignatureFieldPathBuilder {
5463 OpenSignatureFieldPathBuilder::new()
5464 }
5465 }
5466 pub struct OpenSignatureFieldPathBuilder {
5467 path: Vec<&'static str>,
5468 }
5469 impl OpenSignatureFieldPathBuilder {
5470 #[allow(clippy::new_without_default)]
5471 pub fn new() -> Self {
5472 Self { path: Default::default() }
5473 }
5474 #[doc(hidden)]
5475 pub fn new_with_base(base: Vec<&'static str>) -> Self {
5476 Self { path: base }
5477 }
5478 pub fn finish(self) -> String {
5479 self.path.join(".")
5480 }
5481 pub fn reference(mut self) -> String {
5482 self.path.push(OpenSignature::REFERENCE_FIELD.name);
5483 self.finish()
5484 }
5485 pub fn body(mut self) -> OpenSignatureBodyFieldPathBuilder {
5486 self.path.push(OpenSignature::BODY_FIELD.name);
5487 OpenSignatureBodyFieldPathBuilder::new_with_base(self.path)
5488 }
5489 }
5490 impl TypeOrigin {
5491 pub const MODULE_NAME_FIELD: &'static MessageField = &MessageField {
5492 name: "module_name",
5493 json_name: "moduleName",
5494 number: 1i32,
5495 message_fields: None,
5496 };
5497 pub const DATATYPE_NAME_FIELD: &'static MessageField = &MessageField {
5498 name: "datatype_name",
5499 json_name: "datatypeName",
5500 number: 2i32,
5501 message_fields: None,
5502 };
5503 pub const PACKAGE_ID_FIELD: &'static MessageField = &MessageField {
5504 name: "package_id",
5505 json_name: "packageId",
5506 number: 3i32,
5507 message_fields: None,
5508 };
5509 }
5510 impl MessageFields for TypeOrigin {
5511 const FIELDS: &'static [&'static MessageField] = &[
5512 Self::MODULE_NAME_FIELD,
5513 Self::DATATYPE_NAME_FIELD,
5514 Self::PACKAGE_ID_FIELD,
5515 ];
5516 }
5517 impl TypeOrigin {
5518 pub fn path_builder() -> TypeOriginFieldPathBuilder {
5519 TypeOriginFieldPathBuilder::new()
5520 }
5521 }
5522 pub struct TypeOriginFieldPathBuilder {
5523 path: Vec<&'static str>,
5524 }
5525 impl TypeOriginFieldPathBuilder {
5526 #[allow(clippy::new_without_default)]
5527 pub fn new() -> Self {
5528 Self { path: Default::default() }
5529 }
5530 #[doc(hidden)]
5531 pub fn new_with_base(base: Vec<&'static str>) -> Self {
5532 Self { path: base }
5533 }
5534 pub fn finish(self) -> String {
5535 self.path.join(".")
5536 }
5537 pub fn module_name(mut self) -> String {
5538 self.path.push(TypeOrigin::MODULE_NAME_FIELD.name);
5539 self.finish()
5540 }
5541 pub fn datatype_name(mut self) -> String {
5542 self.path.push(TypeOrigin::DATATYPE_NAME_FIELD.name);
5543 self.finish()
5544 }
5545 pub fn package_id(mut self) -> String {
5546 self.path.push(TypeOrigin::PACKAGE_ID_FIELD.name);
5547 self.finish()
5548 }
5549 }
5550 impl Linkage {
5551 pub const ORIGINAL_ID_FIELD: &'static MessageField = &MessageField {
5552 name: "original_id",
5553 json_name: "originalId",
5554 number: 1i32,
5555 message_fields: None,
5556 };
5557 pub const UPGRADED_ID_FIELD: &'static MessageField = &MessageField {
5558 name: "upgraded_id",
5559 json_name: "upgradedId",
5560 number: 2i32,
5561 message_fields: None,
5562 };
5563 pub const UPGRADED_VERSION_FIELD: &'static MessageField = &MessageField {
5564 name: "upgraded_version",
5565 json_name: "upgradedVersion",
5566 number: 3i32,
5567 message_fields: None,
5568 };
5569 }
5570 impl MessageFields for Linkage {
5571 const FIELDS: &'static [&'static MessageField] = &[
5572 Self::ORIGINAL_ID_FIELD,
5573 Self::UPGRADED_ID_FIELD,
5574 Self::UPGRADED_VERSION_FIELD,
5575 ];
5576 }
5577 impl Linkage {
5578 pub fn path_builder() -> LinkageFieldPathBuilder {
5579 LinkageFieldPathBuilder::new()
5580 }
5581 }
5582 pub struct LinkageFieldPathBuilder {
5583 path: Vec<&'static str>,
5584 }
5585 impl LinkageFieldPathBuilder {
5586 #[allow(clippy::new_without_default)]
5587 pub fn new() -> Self {
5588 Self { path: Default::default() }
5589 }
5590 #[doc(hidden)]
5591 pub fn new_with_base(base: Vec<&'static str>) -> Self {
5592 Self { path: base }
5593 }
5594 pub fn finish(self) -> String {
5595 self.path.join(".")
5596 }
5597 pub fn original_id(mut self) -> String {
5598 self.path.push(Linkage::ORIGINAL_ID_FIELD.name);
5599 self.finish()
5600 }
5601 pub fn upgraded_id(mut self) -> String {
5602 self.path.push(Linkage::UPGRADED_ID_FIELD.name);
5603 self.finish()
5604 }
5605 pub fn upgraded_version(mut self) -> String {
5606 self.path.push(Linkage::UPGRADED_VERSION_FIELD.name);
5607 self.finish()
5608 }
5609 }
5610 impl GetPackageRequest {
5611 pub const PACKAGE_ID_FIELD: &'static MessageField = &MessageField {
5612 name: "package_id",
5613 json_name: "packageId",
5614 number: 1i32,
5615 message_fields: None,
5616 };
5617 }
5618 impl MessageFields for GetPackageRequest {
5619 const FIELDS: &'static [&'static MessageField] = &[Self::PACKAGE_ID_FIELD];
5620 }
5621 impl GetPackageRequest {
5622 pub fn path_builder() -> GetPackageRequestFieldPathBuilder {
5623 GetPackageRequestFieldPathBuilder::new()
5624 }
5625 }
5626 pub struct GetPackageRequestFieldPathBuilder {
5627 path: Vec<&'static str>,
5628 }
5629 impl GetPackageRequestFieldPathBuilder {
5630 #[allow(clippy::new_without_default)]
5631 pub fn new() -> Self {
5632 Self { path: Default::default() }
5633 }
5634 #[doc(hidden)]
5635 pub fn new_with_base(base: Vec<&'static str>) -> Self {
5636 Self { path: base }
5637 }
5638 pub fn finish(self) -> String {
5639 self.path.join(".")
5640 }
5641 pub fn package_id(mut self) -> String {
5642 self.path.push(GetPackageRequest::PACKAGE_ID_FIELD.name);
5643 self.finish()
5644 }
5645 }
5646 impl GetPackageResponse {
5647 pub const PACKAGE_FIELD: &'static MessageField = &MessageField {
5648 name: "package",
5649 json_name: "package",
5650 number: 1i32,
5651 message_fields: Some(Package::FIELDS),
5652 };
5653 }
5654 impl MessageFields for GetPackageResponse {
5655 const FIELDS: &'static [&'static MessageField] = &[Self::PACKAGE_FIELD];
5656 }
5657 impl GetPackageResponse {
5658 pub fn path_builder() -> GetPackageResponseFieldPathBuilder {
5659 GetPackageResponseFieldPathBuilder::new()
5660 }
5661 }
5662 pub struct GetPackageResponseFieldPathBuilder {
5663 path: Vec<&'static str>,
5664 }
5665 impl GetPackageResponseFieldPathBuilder {
5666 #[allow(clippy::new_without_default)]
5667 pub fn new() -> Self {
5668 Self { path: Default::default() }
5669 }
5670 #[doc(hidden)]
5671 pub fn new_with_base(base: Vec<&'static str>) -> Self {
5672 Self { path: base }
5673 }
5674 pub fn finish(self) -> String {
5675 self.path.join(".")
5676 }
5677 pub fn package(mut self) -> PackageFieldPathBuilder {
5678 self.path.push(GetPackageResponse::PACKAGE_FIELD.name);
5679 PackageFieldPathBuilder::new_with_base(self.path)
5680 }
5681 }
5682 impl GetDatatypeRequest {
5683 pub const PACKAGE_ID_FIELD: &'static MessageField = &MessageField {
5684 name: "package_id",
5685 json_name: "packageId",
5686 number: 1i32,
5687 message_fields: None,
5688 };
5689 pub const MODULE_NAME_FIELD: &'static MessageField = &MessageField {
5690 name: "module_name",
5691 json_name: "moduleName",
5692 number: 2i32,
5693 message_fields: None,
5694 };
5695 pub const NAME_FIELD: &'static MessageField = &MessageField {
5696 name: "name",
5697 json_name: "name",
5698 number: 3i32,
5699 message_fields: None,
5700 };
5701 }
5702 impl MessageFields for GetDatatypeRequest {
5703 const FIELDS: &'static [&'static MessageField] = &[
5704 Self::PACKAGE_ID_FIELD,
5705 Self::MODULE_NAME_FIELD,
5706 Self::NAME_FIELD,
5707 ];
5708 }
5709 impl GetDatatypeRequest {
5710 pub fn path_builder() -> GetDatatypeRequestFieldPathBuilder {
5711 GetDatatypeRequestFieldPathBuilder::new()
5712 }
5713 }
5714 pub struct GetDatatypeRequestFieldPathBuilder {
5715 path: Vec<&'static str>,
5716 }
5717 impl GetDatatypeRequestFieldPathBuilder {
5718 #[allow(clippy::new_without_default)]
5719 pub fn new() -> Self {
5720 Self { path: Default::default() }
5721 }
5722 #[doc(hidden)]
5723 pub fn new_with_base(base: Vec<&'static str>) -> Self {
5724 Self { path: base }
5725 }
5726 pub fn finish(self) -> String {
5727 self.path.join(".")
5728 }
5729 pub fn package_id(mut self) -> String {
5730 self.path.push(GetDatatypeRequest::PACKAGE_ID_FIELD.name);
5731 self.finish()
5732 }
5733 pub fn module_name(mut self) -> String {
5734 self.path.push(GetDatatypeRequest::MODULE_NAME_FIELD.name);
5735 self.finish()
5736 }
5737 pub fn name(mut self) -> String {
5738 self.path.push(GetDatatypeRequest::NAME_FIELD.name);
5739 self.finish()
5740 }
5741 }
5742 impl GetDatatypeResponse {
5743 pub const DATATYPE_FIELD: &'static MessageField = &MessageField {
5744 name: "datatype",
5745 json_name: "datatype",
5746 number: 1i32,
5747 message_fields: Some(DatatypeDescriptor::FIELDS),
5748 };
5749 }
5750 impl MessageFields for GetDatatypeResponse {
5751 const FIELDS: &'static [&'static MessageField] = &[Self::DATATYPE_FIELD];
5752 }
5753 impl GetDatatypeResponse {
5754 pub fn path_builder() -> GetDatatypeResponseFieldPathBuilder {
5755 GetDatatypeResponseFieldPathBuilder::new()
5756 }
5757 }
5758 pub struct GetDatatypeResponseFieldPathBuilder {
5759 path: Vec<&'static str>,
5760 }
5761 impl GetDatatypeResponseFieldPathBuilder {
5762 #[allow(clippy::new_without_default)]
5763 pub fn new() -> Self {
5764 Self { path: Default::default() }
5765 }
5766 #[doc(hidden)]
5767 pub fn new_with_base(base: Vec<&'static str>) -> Self {
5768 Self { path: base }
5769 }
5770 pub fn finish(self) -> String {
5771 self.path.join(".")
5772 }
5773 pub fn datatype(mut self) -> DatatypeDescriptorFieldPathBuilder {
5774 self.path.push(GetDatatypeResponse::DATATYPE_FIELD.name);
5775 DatatypeDescriptorFieldPathBuilder::new_with_base(self.path)
5776 }
5777 }
5778 impl GetFunctionRequest {
5779 pub const PACKAGE_ID_FIELD: &'static MessageField = &MessageField {
5780 name: "package_id",
5781 json_name: "packageId",
5782 number: 1i32,
5783 message_fields: None,
5784 };
5785 pub const MODULE_NAME_FIELD: &'static MessageField = &MessageField {
5786 name: "module_name",
5787 json_name: "moduleName",
5788 number: 2i32,
5789 message_fields: None,
5790 };
5791 pub const NAME_FIELD: &'static MessageField = &MessageField {
5792 name: "name",
5793 json_name: "name",
5794 number: 3i32,
5795 message_fields: None,
5796 };
5797 }
5798 impl MessageFields for GetFunctionRequest {
5799 const FIELDS: &'static [&'static MessageField] = &[
5800 Self::PACKAGE_ID_FIELD,
5801 Self::MODULE_NAME_FIELD,
5802 Self::NAME_FIELD,
5803 ];
5804 }
5805 impl GetFunctionRequest {
5806 pub fn path_builder() -> GetFunctionRequestFieldPathBuilder {
5807 GetFunctionRequestFieldPathBuilder::new()
5808 }
5809 }
5810 pub struct GetFunctionRequestFieldPathBuilder {
5811 path: Vec<&'static str>,
5812 }
5813 impl GetFunctionRequestFieldPathBuilder {
5814 #[allow(clippy::new_without_default)]
5815 pub fn new() -> Self {
5816 Self { path: Default::default() }
5817 }
5818 #[doc(hidden)]
5819 pub fn new_with_base(base: Vec<&'static str>) -> Self {
5820 Self { path: base }
5821 }
5822 pub fn finish(self) -> String {
5823 self.path.join(".")
5824 }
5825 pub fn package_id(mut self) -> String {
5826 self.path.push(GetFunctionRequest::PACKAGE_ID_FIELD.name);
5827 self.finish()
5828 }
5829 pub fn module_name(mut self) -> String {
5830 self.path.push(GetFunctionRequest::MODULE_NAME_FIELD.name);
5831 self.finish()
5832 }
5833 pub fn name(mut self) -> String {
5834 self.path.push(GetFunctionRequest::NAME_FIELD.name);
5835 self.finish()
5836 }
5837 }
5838 impl GetFunctionResponse {
5839 pub const FUNCTION_FIELD: &'static MessageField = &MessageField {
5840 name: "function",
5841 json_name: "function",
5842 number: 1i32,
5843 message_fields: Some(FunctionDescriptor::FIELDS),
5844 };
5845 }
5846 impl MessageFields for GetFunctionResponse {
5847 const FIELDS: &'static [&'static MessageField] = &[Self::FUNCTION_FIELD];
5848 }
5849 impl GetFunctionResponse {
5850 pub fn path_builder() -> GetFunctionResponseFieldPathBuilder {
5851 GetFunctionResponseFieldPathBuilder::new()
5852 }
5853 }
5854 pub struct GetFunctionResponseFieldPathBuilder {
5855 path: Vec<&'static str>,
5856 }
5857 impl GetFunctionResponseFieldPathBuilder {
5858 #[allow(clippy::new_without_default)]
5859 pub fn new() -> Self {
5860 Self { path: Default::default() }
5861 }
5862 #[doc(hidden)]
5863 pub fn new_with_base(base: Vec<&'static str>) -> Self {
5864 Self { path: base }
5865 }
5866 pub fn finish(self) -> String {
5867 self.path.join(".")
5868 }
5869 pub fn function(mut self) -> FunctionDescriptorFieldPathBuilder {
5870 self.path.push(GetFunctionResponse::FUNCTION_FIELD.name);
5871 FunctionDescriptorFieldPathBuilder::new_with_base(self.path)
5872 }
5873 }
5874 impl ListPackageVersionsRequest {
5875 pub const PACKAGE_ID_FIELD: &'static MessageField = &MessageField {
5876 name: "package_id",
5877 json_name: "packageId",
5878 number: 1i32,
5879 message_fields: None,
5880 };
5881 pub const PAGE_SIZE_FIELD: &'static MessageField = &MessageField {
5882 name: "page_size",
5883 json_name: "pageSize",
5884 number: 2i32,
5885 message_fields: None,
5886 };
5887 pub const PAGE_TOKEN_FIELD: &'static MessageField = &MessageField {
5888 name: "page_token",
5889 json_name: "pageToken",
5890 number: 3i32,
5891 message_fields: None,
5892 };
5893 }
5894 impl MessageFields for ListPackageVersionsRequest {
5895 const FIELDS: &'static [&'static MessageField] = &[
5896 Self::PACKAGE_ID_FIELD,
5897 Self::PAGE_SIZE_FIELD,
5898 Self::PAGE_TOKEN_FIELD,
5899 ];
5900 }
5901 impl ListPackageVersionsRequest {
5902 pub fn path_builder() -> ListPackageVersionsRequestFieldPathBuilder {
5903 ListPackageVersionsRequestFieldPathBuilder::new()
5904 }
5905 }
5906 pub struct ListPackageVersionsRequestFieldPathBuilder {
5907 path: Vec<&'static str>,
5908 }
5909 impl ListPackageVersionsRequestFieldPathBuilder {
5910 #[allow(clippy::new_without_default)]
5911 pub fn new() -> Self {
5912 Self { path: Default::default() }
5913 }
5914 #[doc(hidden)]
5915 pub fn new_with_base(base: Vec<&'static str>) -> Self {
5916 Self { path: base }
5917 }
5918 pub fn finish(self) -> String {
5919 self.path.join(".")
5920 }
5921 pub fn package_id(mut self) -> String {
5922 self.path.push(ListPackageVersionsRequest::PACKAGE_ID_FIELD.name);
5923 self.finish()
5924 }
5925 pub fn page_size(mut self) -> String {
5926 self.path.push(ListPackageVersionsRequest::PAGE_SIZE_FIELD.name);
5927 self.finish()
5928 }
5929 pub fn page_token(mut self) -> String {
5930 self.path.push(ListPackageVersionsRequest::PAGE_TOKEN_FIELD.name);
5931 self.finish()
5932 }
5933 }
5934 impl ListPackageVersionsResponse {
5935 pub const VERSIONS_FIELD: &'static MessageField = &MessageField {
5936 name: "versions",
5937 json_name: "versions",
5938 number: 1i32,
5939 message_fields: Some(PackageVersion::FIELDS),
5940 };
5941 pub const NEXT_PAGE_TOKEN_FIELD: &'static MessageField = &MessageField {
5942 name: "next_page_token",
5943 json_name: "nextPageToken",
5944 number: 2i32,
5945 message_fields: None,
5946 };
5947 }
5948 impl MessageFields for ListPackageVersionsResponse {
5949 const FIELDS: &'static [&'static MessageField] = &[
5950 Self::VERSIONS_FIELD,
5951 Self::NEXT_PAGE_TOKEN_FIELD,
5952 ];
5953 }
5954 impl ListPackageVersionsResponse {
5955 pub fn path_builder() -> ListPackageVersionsResponseFieldPathBuilder {
5956 ListPackageVersionsResponseFieldPathBuilder::new()
5957 }
5958 }
5959 pub struct ListPackageVersionsResponseFieldPathBuilder {
5960 path: Vec<&'static str>,
5961 }
5962 impl ListPackageVersionsResponseFieldPathBuilder {
5963 #[allow(clippy::new_without_default)]
5964 pub fn new() -> Self {
5965 Self { path: Default::default() }
5966 }
5967 #[doc(hidden)]
5968 pub fn new_with_base(base: Vec<&'static str>) -> Self {
5969 Self { path: base }
5970 }
5971 pub fn finish(self) -> String {
5972 self.path.join(".")
5973 }
5974 pub fn versions(mut self) -> PackageVersionFieldPathBuilder {
5975 self.path.push(ListPackageVersionsResponse::VERSIONS_FIELD.name);
5976 PackageVersionFieldPathBuilder::new_with_base(self.path)
5977 }
5978 pub fn next_page_token(mut self) -> String {
5979 self.path.push(ListPackageVersionsResponse::NEXT_PAGE_TOKEN_FIELD.name);
5980 self.finish()
5981 }
5982 }
5983 impl PackageVersion {
5984 pub const PACKAGE_ID_FIELD: &'static MessageField = &MessageField {
5985 name: "package_id",
5986 json_name: "packageId",
5987 number: 1i32,
5988 message_fields: None,
5989 };
5990 pub const VERSION_FIELD: &'static MessageField = &MessageField {
5991 name: "version",
5992 json_name: "version",
5993 number: 2i32,
5994 message_fields: None,
5995 };
5996 }
5997 impl MessageFields for PackageVersion {
5998 const FIELDS: &'static [&'static MessageField] = &[
5999 Self::PACKAGE_ID_FIELD,
6000 Self::VERSION_FIELD,
6001 ];
6002 }
6003 impl PackageVersion {
6004 pub fn path_builder() -> PackageVersionFieldPathBuilder {
6005 PackageVersionFieldPathBuilder::new()
6006 }
6007 }
6008 pub struct PackageVersionFieldPathBuilder {
6009 path: Vec<&'static str>,
6010 }
6011 impl PackageVersionFieldPathBuilder {
6012 #[allow(clippy::new_without_default)]
6013 pub fn new() -> Self {
6014 Self { path: Default::default() }
6015 }
6016 #[doc(hidden)]
6017 pub fn new_with_base(base: Vec<&'static str>) -> Self {
6018 Self { path: base }
6019 }
6020 pub fn finish(self) -> String {
6021 self.path.join(".")
6022 }
6023 pub fn package_id(mut self) -> String {
6024 self.path.push(PackageVersion::PACKAGE_ID_FIELD.name);
6025 self.finish()
6026 }
6027 pub fn version(mut self) -> String {
6028 self.path.push(PackageVersion::VERSION_FIELD.name);
6029 self.finish()
6030 }
6031 }
6032 impl LookupNameRequest {
6033 pub const NAME_FIELD: &'static MessageField = &MessageField {
6034 name: "name",
6035 json_name: "name",
6036 number: 1i32,
6037 message_fields: None,
6038 };
6039 }
6040 impl MessageFields for LookupNameRequest {
6041 const FIELDS: &'static [&'static MessageField] = &[Self::NAME_FIELD];
6042 }
6043 impl LookupNameRequest {
6044 pub fn path_builder() -> LookupNameRequestFieldPathBuilder {
6045 LookupNameRequestFieldPathBuilder::new()
6046 }
6047 }
6048 pub struct LookupNameRequestFieldPathBuilder {
6049 path: Vec<&'static str>,
6050 }
6051 impl LookupNameRequestFieldPathBuilder {
6052 #[allow(clippy::new_without_default)]
6053 pub fn new() -> Self {
6054 Self { path: Default::default() }
6055 }
6056 #[doc(hidden)]
6057 pub fn new_with_base(base: Vec<&'static str>) -> Self {
6058 Self { path: base }
6059 }
6060 pub fn finish(self) -> String {
6061 self.path.join(".")
6062 }
6063 pub fn name(mut self) -> String {
6064 self.path.push(LookupNameRequest::NAME_FIELD.name);
6065 self.finish()
6066 }
6067 }
6068 impl LookupNameResponse {
6069 pub const RECORD_FIELD: &'static MessageField = &MessageField {
6070 name: "record",
6071 json_name: "record",
6072 number: 1i32,
6073 message_fields: Some(NameRecord::FIELDS),
6074 };
6075 }
6076 impl MessageFields for LookupNameResponse {
6077 const FIELDS: &'static [&'static MessageField] = &[Self::RECORD_FIELD];
6078 }
6079 impl LookupNameResponse {
6080 pub fn path_builder() -> LookupNameResponseFieldPathBuilder {
6081 LookupNameResponseFieldPathBuilder::new()
6082 }
6083 }
6084 pub struct LookupNameResponseFieldPathBuilder {
6085 path: Vec<&'static str>,
6086 }
6087 impl LookupNameResponseFieldPathBuilder {
6088 #[allow(clippy::new_without_default)]
6089 pub fn new() -> Self {
6090 Self { path: Default::default() }
6091 }
6092 #[doc(hidden)]
6093 pub fn new_with_base(base: Vec<&'static str>) -> Self {
6094 Self { path: base }
6095 }
6096 pub fn finish(self) -> String {
6097 self.path.join(".")
6098 }
6099 pub fn record(mut self) -> NameRecordFieldPathBuilder {
6100 self.path.push(LookupNameResponse::RECORD_FIELD.name);
6101 NameRecordFieldPathBuilder::new_with_base(self.path)
6102 }
6103 }
6104 impl ReverseLookupNameRequest {
6105 pub const ADDRESS_FIELD: &'static MessageField = &MessageField {
6106 name: "address",
6107 json_name: "address",
6108 number: 1i32,
6109 message_fields: None,
6110 };
6111 }
6112 impl MessageFields for ReverseLookupNameRequest {
6113 const FIELDS: &'static [&'static MessageField] = &[Self::ADDRESS_FIELD];
6114 }
6115 impl ReverseLookupNameRequest {
6116 pub fn path_builder() -> ReverseLookupNameRequestFieldPathBuilder {
6117 ReverseLookupNameRequestFieldPathBuilder::new()
6118 }
6119 }
6120 pub struct ReverseLookupNameRequestFieldPathBuilder {
6121 path: Vec<&'static str>,
6122 }
6123 impl ReverseLookupNameRequestFieldPathBuilder {
6124 #[allow(clippy::new_without_default)]
6125 pub fn new() -> Self {
6126 Self { path: Default::default() }
6127 }
6128 #[doc(hidden)]
6129 pub fn new_with_base(base: Vec<&'static str>) -> Self {
6130 Self { path: base }
6131 }
6132 pub fn finish(self) -> String {
6133 self.path.join(".")
6134 }
6135 pub fn address(mut self) -> String {
6136 self.path.push(ReverseLookupNameRequest::ADDRESS_FIELD.name);
6137 self.finish()
6138 }
6139 }
6140 impl ReverseLookupNameResponse {
6141 pub const RECORD_FIELD: &'static MessageField = &MessageField {
6142 name: "record",
6143 json_name: "record",
6144 number: 1i32,
6145 message_fields: Some(NameRecord::FIELDS),
6146 };
6147 }
6148 impl MessageFields for ReverseLookupNameResponse {
6149 const FIELDS: &'static [&'static MessageField] = &[Self::RECORD_FIELD];
6150 }
6151 impl ReverseLookupNameResponse {
6152 pub fn path_builder() -> ReverseLookupNameResponseFieldPathBuilder {
6153 ReverseLookupNameResponseFieldPathBuilder::new()
6154 }
6155 }
6156 pub struct ReverseLookupNameResponseFieldPathBuilder {
6157 path: Vec<&'static str>,
6158 }
6159 impl ReverseLookupNameResponseFieldPathBuilder {
6160 #[allow(clippy::new_without_default)]
6161 pub fn new() -> Self {
6162 Self { path: Default::default() }
6163 }
6164 #[doc(hidden)]
6165 pub fn new_with_base(base: Vec<&'static str>) -> Self {
6166 Self { path: base }
6167 }
6168 pub fn finish(self) -> String {
6169 self.path.join(".")
6170 }
6171 pub fn record(mut self) -> NameRecordFieldPathBuilder {
6172 self.path.push(ReverseLookupNameResponse::RECORD_FIELD.name);
6173 NameRecordFieldPathBuilder::new_with_base(self.path)
6174 }
6175 }
6176 impl NameRecord {
6177 pub const ID_FIELD: &'static MessageField = &MessageField {
6178 name: "id",
6179 json_name: "id",
6180 number: 1i32,
6181 message_fields: None,
6182 };
6183 pub const NAME_FIELD: &'static MessageField = &MessageField {
6184 name: "name",
6185 json_name: "name",
6186 number: 2i32,
6187 message_fields: None,
6188 };
6189 pub const REGISTRATION_NFT_ID_FIELD: &'static MessageField = &MessageField {
6190 name: "registration_nft_id",
6191 json_name: "registrationNftId",
6192 number: 3i32,
6193 message_fields: None,
6194 };
6195 pub const EXPIRATION_TIMESTAMP_FIELD: &'static MessageField = &MessageField {
6196 name: "expiration_timestamp",
6197 json_name: "expirationTimestamp",
6198 number: 4i32,
6199 message_fields: None,
6200 };
6201 pub const TARGET_ADDRESS_FIELD: &'static MessageField = &MessageField {
6202 name: "target_address",
6203 json_name: "targetAddress",
6204 number: 5i32,
6205 message_fields: None,
6206 };
6207 pub const DATA_FIELD: &'static MessageField = &MessageField {
6208 name: "data",
6209 json_name: "data",
6210 number: 6i32,
6211 message_fields: None,
6212 };
6213 }
6214 impl MessageFields for NameRecord {
6215 const FIELDS: &'static [&'static MessageField] = &[
6216 Self::ID_FIELD,
6217 Self::NAME_FIELD,
6218 Self::REGISTRATION_NFT_ID_FIELD,
6219 Self::EXPIRATION_TIMESTAMP_FIELD,
6220 Self::TARGET_ADDRESS_FIELD,
6221 Self::DATA_FIELD,
6222 ];
6223 }
6224 impl NameRecord {
6225 pub fn path_builder() -> NameRecordFieldPathBuilder {
6226 NameRecordFieldPathBuilder::new()
6227 }
6228 }
6229 pub struct NameRecordFieldPathBuilder {
6230 path: Vec<&'static str>,
6231 }
6232 impl NameRecordFieldPathBuilder {
6233 #[allow(clippy::new_without_default)]
6234 pub fn new() -> Self {
6235 Self { path: Default::default() }
6236 }
6237 #[doc(hidden)]
6238 pub fn new_with_base(base: Vec<&'static str>) -> Self {
6239 Self { path: base }
6240 }
6241 pub fn finish(self) -> String {
6242 self.path.join(".")
6243 }
6244 pub fn id(mut self) -> String {
6245 self.path.push(NameRecord::ID_FIELD.name);
6246 self.finish()
6247 }
6248 pub fn name(mut self) -> String {
6249 self.path.push(NameRecord::NAME_FIELD.name);
6250 self.finish()
6251 }
6252 pub fn registration_nft_id(mut self) -> String {
6253 self.path.push(NameRecord::REGISTRATION_NFT_ID_FIELD.name);
6254 self.finish()
6255 }
6256 pub fn expiration_timestamp(mut self) -> String {
6257 self.path.push(NameRecord::EXPIRATION_TIMESTAMP_FIELD.name);
6258 self.finish()
6259 }
6260 pub fn target_address(mut self) -> String {
6261 self.path.push(NameRecord::TARGET_ADDRESS_FIELD.name);
6262 self.finish()
6263 }
6264 pub fn data(mut self) -> String {
6265 self.path.push(NameRecord::DATA_FIELD.name);
6266 self.finish()
6267 }
6268 }
6269 impl Object {
6270 pub const BCS_FIELD: &'static MessageField = &MessageField {
6271 name: "bcs",
6272 json_name: "bcs",
6273 number: 1i32,
6274 message_fields: Some(Bcs::FIELDS),
6275 };
6276 pub const OBJECT_ID_FIELD: &'static MessageField = &MessageField {
6277 name: "object_id",
6278 json_name: "objectId",
6279 number: 2i32,
6280 message_fields: None,
6281 };
6282 pub const VERSION_FIELD: &'static MessageField = &MessageField {
6283 name: "version",
6284 json_name: "version",
6285 number: 3i32,
6286 message_fields: None,
6287 };
6288 pub const DIGEST_FIELD: &'static MessageField = &MessageField {
6289 name: "digest",
6290 json_name: "digest",
6291 number: 4i32,
6292 message_fields: None,
6293 };
6294 pub const OWNER_FIELD: &'static MessageField = &MessageField {
6295 name: "owner",
6296 json_name: "owner",
6297 number: 5i32,
6298 message_fields: Some(Owner::FIELDS),
6299 };
6300 pub const OBJECT_TYPE_FIELD: &'static MessageField = &MessageField {
6301 name: "object_type",
6302 json_name: "objectType",
6303 number: 6i32,
6304 message_fields: None,
6305 };
6306 pub const HAS_PUBLIC_TRANSFER_FIELD: &'static MessageField = &MessageField {
6307 name: "has_public_transfer",
6308 json_name: "hasPublicTransfer",
6309 number: 7i32,
6310 message_fields: None,
6311 };
6312 pub const CONTENTS_FIELD: &'static MessageField = &MessageField {
6313 name: "contents",
6314 json_name: "contents",
6315 number: 8i32,
6316 message_fields: Some(Bcs::FIELDS),
6317 };
6318 pub const PACKAGE_FIELD: &'static MessageField = &MessageField {
6319 name: "package",
6320 json_name: "package",
6321 number: 9i32,
6322 message_fields: Some(Package::FIELDS),
6323 };
6324 pub const PREVIOUS_TRANSACTION_FIELD: &'static MessageField = &MessageField {
6325 name: "previous_transaction",
6326 json_name: "previousTransaction",
6327 number: 10i32,
6328 message_fields: None,
6329 };
6330 pub const STORAGE_REBATE_FIELD: &'static MessageField = &MessageField {
6331 name: "storage_rebate",
6332 json_name: "storageRebate",
6333 number: 11i32,
6334 message_fields: None,
6335 };
6336 pub const JSON_FIELD: &'static MessageField = &MessageField {
6337 name: "json",
6338 json_name: "json",
6339 number: 100i32,
6340 message_fields: None,
6341 };
6342 pub const BALANCE_FIELD: &'static MessageField = &MessageField {
6343 name: "balance",
6344 json_name: "balance",
6345 number: 101i32,
6346 message_fields: None,
6347 };
6348 pub const DISPLAY_FIELD: &'static MessageField = &MessageField {
6349 name: "display",
6350 json_name: "display",
6351 number: 102i32,
6352 message_fields: Some(Display::FIELDS),
6353 };
6354 }
6355 impl MessageFields for Object {
6356 const FIELDS: &'static [&'static MessageField] = &[
6357 Self::BCS_FIELD,
6358 Self::OBJECT_ID_FIELD,
6359 Self::VERSION_FIELD,
6360 Self::DIGEST_FIELD,
6361 Self::OWNER_FIELD,
6362 Self::OBJECT_TYPE_FIELD,
6363 Self::HAS_PUBLIC_TRANSFER_FIELD,
6364 Self::CONTENTS_FIELD,
6365 Self::PACKAGE_FIELD,
6366 Self::PREVIOUS_TRANSACTION_FIELD,
6367 Self::STORAGE_REBATE_FIELD,
6368 Self::JSON_FIELD,
6369 Self::BALANCE_FIELD,
6370 Self::DISPLAY_FIELD,
6371 ];
6372 }
6373 impl Object {
6374 pub fn path_builder() -> ObjectFieldPathBuilder {
6375 ObjectFieldPathBuilder::new()
6376 }
6377 }
6378 pub struct ObjectFieldPathBuilder {
6379 path: Vec<&'static str>,
6380 }
6381 impl ObjectFieldPathBuilder {
6382 #[allow(clippy::new_without_default)]
6383 pub fn new() -> Self {
6384 Self { path: Default::default() }
6385 }
6386 #[doc(hidden)]
6387 pub fn new_with_base(base: Vec<&'static str>) -> Self {
6388 Self { path: base }
6389 }
6390 pub fn finish(self) -> String {
6391 self.path.join(".")
6392 }
6393 pub fn bcs(mut self) -> BcsFieldPathBuilder {
6394 self.path.push(Object::BCS_FIELD.name);
6395 BcsFieldPathBuilder::new_with_base(self.path)
6396 }
6397 pub fn object_id(mut self) -> String {
6398 self.path.push(Object::OBJECT_ID_FIELD.name);
6399 self.finish()
6400 }
6401 pub fn version(mut self) -> String {
6402 self.path.push(Object::VERSION_FIELD.name);
6403 self.finish()
6404 }
6405 pub fn digest(mut self) -> String {
6406 self.path.push(Object::DIGEST_FIELD.name);
6407 self.finish()
6408 }
6409 pub fn owner(mut self) -> OwnerFieldPathBuilder {
6410 self.path.push(Object::OWNER_FIELD.name);
6411 OwnerFieldPathBuilder::new_with_base(self.path)
6412 }
6413 pub fn object_type(mut self) -> String {
6414 self.path.push(Object::OBJECT_TYPE_FIELD.name);
6415 self.finish()
6416 }
6417 pub fn has_public_transfer(mut self) -> String {
6418 self.path.push(Object::HAS_PUBLIC_TRANSFER_FIELD.name);
6419 self.finish()
6420 }
6421 pub fn contents(mut self) -> BcsFieldPathBuilder {
6422 self.path.push(Object::CONTENTS_FIELD.name);
6423 BcsFieldPathBuilder::new_with_base(self.path)
6424 }
6425 pub fn package(mut self) -> PackageFieldPathBuilder {
6426 self.path.push(Object::PACKAGE_FIELD.name);
6427 PackageFieldPathBuilder::new_with_base(self.path)
6428 }
6429 pub fn previous_transaction(mut self) -> String {
6430 self.path.push(Object::PREVIOUS_TRANSACTION_FIELD.name);
6431 self.finish()
6432 }
6433 pub fn storage_rebate(mut self) -> String {
6434 self.path.push(Object::STORAGE_REBATE_FIELD.name);
6435 self.finish()
6436 }
6437 pub fn json(mut self) -> String {
6438 self.path.push(Object::JSON_FIELD.name);
6439 self.finish()
6440 }
6441 pub fn balance(mut self) -> String {
6442 self.path.push(Object::BALANCE_FIELD.name);
6443 self.finish()
6444 }
6445 pub fn display(mut self) -> DisplayFieldPathBuilder {
6446 self.path.push(Object::DISPLAY_FIELD.name);
6447 DisplayFieldPathBuilder::new_with_base(self.path)
6448 }
6449 }
6450 impl ObjectSet {
6451 pub const OBJECTS_FIELD: &'static MessageField = &MessageField {
6452 name: "objects",
6453 json_name: "objects",
6454 number: 1i32,
6455 message_fields: Some(Object::FIELDS),
6456 };
6457 }
6458 impl MessageFields for ObjectSet {
6459 const FIELDS: &'static [&'static MessageField] = &[Self::OBJECTS_FIELD];
6460 }
6461 impl ObjectSet {
6462 pub fn path_builder() -> ObjectSetFieldPathBuilder {
6463 ObjectSetFieldPathBuilder::new()
6464 }
6465 }
6466 pub struct ObjectSetFieldPathBuilder {
6467 path: Vec<&'static str>,
6468 }
6469 impl ObjectSetFieldPathBuilder {
6470 #[allow(clippy::new_without_default)]
6471 pub fn new() -> Self {
6472 Self { path: Default::default() }
6473 }
6474 #[doc(hidden)]
6475 pub fn new_with_base(base: Vec<&'static str>) -> Self {
6476 Self { path: base }
6477 }
6478 pub fn finish(self) -> String {
6479 self.path.join(".")
6480 }
6481 pub fn objects(mut self) -> ObjectFieldPathBuilder {
6482 self.path.push(ObjectSet::OBJECTS_FIELD.name);
6483 ObjectFieldPathBuilder::new_with_base(self.path)
6484 }
6485 }
6486 impl Display {
6487 pub const OUTPUT_FIELD: &'static MessageField = &MessageField {
6488 name: "output",
6489 json_name: "output",
6490 number: 1i32,
6491 message_fields: None,
6492 };
6493 pub const ERRORS_FIELD: &'static MessageField = &MessageField {
6494 name: "errors",
6495 json_name: "errors",
6496 number: 2i32,
6497 message_fields: None,
6498 };
6499 }
6500 impl MessageFields for Display {
6501 const FIELDS: &'static [&'static MessageField] = &[
6502 Self::OUTPUT_FIELD,
6503 Self::ERRORS_FIELD,
6504 ];
6505 }
6506 impl Display {
6507 pub fn path_builder() -> DisplayFieldPathBuilder {
6508 DisplayFieldPathBuilder::new()
6509 }
6510 }
6511 pub struct DisplayFieldPathBuilder {
6512 path: Vec<&'static str>,
6513 }
6514 impl DisplayFieldPathBuilder {
6515 #[allow(clippy::new_without_default)]
6516 pub fn new() -> Self {
6517 Self { path: Default::default() }
6518 }
6519 #[doc(hidden)]
6520 pub fn new_with_base(base: Vec<&'static str>) -> Self {
6521 Self { path: base }
6522 }
6523 pub fn finish(self) -> String {
6524 self.path.join(".")
6525 }
6526 pub fn output(mut self) -> String {
6527 self.path.push(Display::OUTPUT_FIELD.name);
6528 self.finish()
6529 }
6530 pub fn errors(mut self) -> String {
6531 self.path.push(Display::ERRORS_FIELD.name);
6532 self.finish()
6533 }
6534 }
6535 impl ObjectReference {
6536 pub const OBJECT_ID_FIELD: &'static MessageField = &MessageField {
6537 name: "object_id",
6538 json_name: "objectId",
6539 number: 1i32,
6540 message_fields: None,
6541 };
6542 pub const VERSION_FIELD: &'static MessageField = &MessageField {
6543 name: "version",
6544 json_name: "version",
6545 number: 2i32,
6546 message_fields: None,
6547 };
6548 pub const DIGEST_FIELD: &'static MessageField = &MessageField {
6549 name: "digest",
6550 json_name: "digest",
6551 number: 3i32,
6552 message_fields: None,
6553 };
6554 }
6555 impl MessageFields for ObjectReference {
6556 const FIELDS: &'static [&'static MessageField] = &[
6557 Self::OBJECT_ID_FIELD,
6558 Self::VERSION_FIELD,
6559 Self::DIGEST_FIELD,
6560 ];
6561 }
6562 impl ObjectReference {
6563 pub fn path_builder() -> ObjectReferenceFieldPathBuilder {
6564 ObjectReferenceFieldPathBuilder::new()
6565 }
6566 }
6567 pub struct ObjectReferenceFieldPathBuilder {
6568 path: Vec<&'static str>,
6569 }
6570 impl ObjectReferenceFieldPathBuilder {
6571 #[allow(clippy::new_without_default)]
6572 pub fn new() -> Self {
6573 Self { path: Default::default() }
6574 }
6575 #[doc(hidden)]
6576 pub fn new_with_base(base: Vec<&'static str>) -> Self {
6577 Self { path: base }
6578 }
6579 pub fn finish(self) -> String {
6580 self.path.join(".")
6581 }
6582 pub fn object_id(mut self) -> String {
6583 self.path.push(ObjectReference::OBJECT_ID_FIELD.name);
6584 self.finish()
6585 }
6586 pub fn version(mut self) -> String {
6587 self.path.push(ObjectReference::VERSION_FIELD.name);
6588 self.finish()
6589 }
6590 pub fn digest(mut self) -> String {
6591 self.path.push(ObjectReference::DIGEST_FIELD.name);
6592 self.finish()
6593 }
6594 }
6595 impl Owner {
6596 pub const KIND_FIELD: &'static MessageField = &MessageField {
6597 name: "kind",
6598 json_name: "kind",
6599 number: 1i32,
6600 message_fields: None,
6601 };
6602 pub const ADDRESS_FIELD: &'static MessageField = &MessageField {
6603 name: "address",
6604 json_name: "address",
6605 number: 2i32,
6606 message_fields: None,
6607 };
6608 pub const VERSION_FIELD: &'static MessageField = &MessageField {
6609 name: "version",
6610 json_name: "version",
6611 number: 3i32,
6612 message_fields: None,
6613 };
6614 }
6615 impl MessageFields for Owner {
6616 const FIELDS: &'static [&'static MessageField] = &[
6617 Self::KIND_FIELD,
6618 Self::ADDRESS_FIELD,
6619 Self::VERSION_FIELD,
6620 ];
6621 }
6622 impl Owner {
6623 pub fn path_builder() -> OwnerFieldPathBuilder {
6624 OwnerFieldPathBuilder::new()
6625 }
6626 }
6627 pub struct OwnerFieldPathBuilder {
6628 path: Vec<&'static str>,
6629 }
6630 impl OwnerFieldPathBuilder {
6631 #[allow(clippy::new_without_default)]
6632 pub fn new() -> Self {
6633 Self { path: Default::default() }
6634 }
6635 #[doc(hidden)]
6636 pub fn new_with_base(base: Vec<&'static str>) -> Self {
6637 Self { path: base }
6638 }
6639 pub fn finish(self) -> String {
6640 self.path.join(".")
6641 }
6642 pub fn kind(mut self) -> String {
6643 self.path.push(Owner::KIND_FIELD.name);
6644 self.finish()
6645 }
6646 pub fn address(mut self) -> String {
6647 self.path.push(Owner::ADDRESS_FIELD.name);
6648 self.finish()
6649 }
6650 pub fn version(mut self) -> String {
6651 self.path.push(Owner::VERSION_FIELD.name);
6652 self.finish()
6653 }
6654 }
6655 impl ProtocolConfig {
6656 pub const PROTOCOL_VERSION_FIELD: &'static MessageField = &MessageField {
6657 name: "protocol_version",
6658 json_name: "protocolVersion",
6659 number: 1i32,
6660 message_fields: None,
6661 };
6662 pub const FEATURE_FLAGS_FIELD: &'static MessageField = &MessageField {
6663 name: "feature_flags",
6664 json_name: "featureFlags",
6665 number: 2i32,
6666 message_fields: None,
6667 };
6668 pub const ATTRIBUTES_FIELD: &'static MessageField = &MessageField {
6669 name: "attributes",
6670 json_name: "attributes",
6671 number: 3i32,
6672 message_fields: None,
6673 };
6674 pub const CONFIGS_FIELD: &'static MessageField = &MessageField {
6675 name: "configs",
6676 json_name: "configs",
6677 number: 4i32,
6678 message_fields: None,
6679 };
6680 }
6681 impl MessageFields for ProtocolConfig {
6682 const FIELDS: &'static [&'static MessageField] = &[
6683 Self::PROTOCOL_VERSION_FIELD,
6684 Self::FEATURE_FLAGS_FIELD,
6685 Self::ATTRIBUTES_FIELD,
6686 Self::CONFIGS_FIELD,
6687 ];
6688 }
6689 impl ProtocolConfig {
6690 pub fn path_builder() -> ProtocolConfigFieldPathBuilder {
6691 ProtocolConfigFieldPathBuilder::new()
6692 }
6693 }
6694 pub struct ProtocolConfigFieldPathBuilder {
6695 path: Vec<&'static str>,
6696 }
6697 impl ProtocolConfigFieldPathBuilder {
6698 #[allow(clippy::new_without_default)]
6699 pub fn new() -> Self {
6700 Self { path: Default::default() }
6701 }
6702 #[doc(hidden)]
6703 pub fn new_with_base(base: Vec<&'static str>) -> Self {
6704 Self { path: base }
6705 }
6706 pub fn finish(self) -> String {
6707 self.path.join(".")
6708 }
6709 pub fn protocol_version(mut self) -> String {
6710 self.path.push(ProtocolConfig::PROTOCOL_VERSION_FIELD.name);
6711 self.finish()
6712 }
6713 pub fn feature_flags(mut self) -> String {
6714 self.path.push(ProtocolConfig::FEATURE_FLAGS_FIELD.name);
6715 self.finish()
6716 }
6717 pub fn attributes(mut self) -> String {
6718 self.path.push(ProtocolConfig::ATTRIBUTES_FIELD.name);
6719 self.finish()
6720 }
6721 pub fn configs(mut self) -> String {
6722 self.path.push(ProtocolConfig::CONFIGS_FIELD.name);
6723 self.finish()
6724 }
6725 }
6726 impl QueryOptions {
6727 pub const LIMIT_FIELD: &'static MessageField = &MessageField {
6728 name: "limit",
6729 json_name: "limit",
6730 number: 1i32,
6731 message_fields: None,
6732 };
6733 pub const AFTER_FIELD: &'static MessageField = &MessageField {
6734 name: "after",
6735 json_name: "after",
6736 number: 2i32,
6737 message_fields: None,
6738 };
6739 pub const BEFORE_FIELD: &'static MessageField = &MessageField {
6740 name: "before",
6741 json_name: "before",
6742 number: 3i32,
6743 message_fields: None,
6744 };
6745 pub const ORDERING_FIELD: &'static MessageField = &MessageField {
6746 name: "ordering",
6747 json_name: "ordering",
6748 number: 4i32,
6749 message_fields: None,
6750 };
6751 }
6752 impl MessageFields for QueryOptions {
6753 const FIELDS: &'static [&'static MessageField] = &[
6754 Self::LIMIT_FIELD,
6755 Self::AFTER_FIELD,
6756 Self::BEFORE_FIELD,
6757 Self::ORDERING_FIELD,
6758 ];
6759 }
6760 impl QueryOptions {
6761 pub fn path_builder() -> QueryOptionsFieldPathBuilder {
6762 QueryOptionsFieldPathBuilder::new()
6763 }
6764 }
6765 pub struct QueryOptionsFieldPathBuilder {
6766 path: Vec<&'static str>,
6767 }
6768 impl QueryOptionsFieldPathBuilder {
6769 #[allow(clippy::new_without_default)]
6770 pub fn new() -> Self {
6771 Self { path: Default::default() }
6772 }
6773 #[doc(hidden)]
6774 pub fn new_with_base(base: Vec<&'static str>) -> Self {
6775 Self { path: base }
6776 }
6777 pub fn finish(self) -> String {
6778 self.path.join(".")
6779 }
6780 pub fn limit(mut self) -> String {
6781 self.path.push(QueryOptions::LIMIT_FIELD.name);
6782 self.finish()
6783 }
6784 pub fn after(mut self) -> String {
6785 self.path.push(QueryOptions::AFTER_FIELD.name);
6786 self.finish()
6787 }
6788 pub fn before(mut self) -> String {
6789 self.path.push(QueryOptions::BEFORE_FIELD.name);
6790 self.finish()
6791 }
6792 pub fn ordering(mut self) -> String {
6793 self.path.push(QueryOptions::ORDERING_FIELD.name);
6794 self.finish()
6795 }
6796 }
6797 impl Watermark {
6798 pub const CURSOR_FIELD: &'static MessageField = &MessageField {
6799 name: "cursor",
6800 json_name: "cursor",
6801 number: 1i32,
6802 message_fields: None,
6803 };
6804 pub const CHECKPOINT_FIELD: &'static MessageField = &MessageField {
6805 name: "checkpoint",
6806 json_name: "checkpoint",
6807 number: 2i32,
6808 message_fields: None,
6809 };
6810 }
6811 impl MessageFields for Watermark {
6812 const FIELDS: &'static [&'static MessageField] = &[
6813 Self::CURSOR_FIELD,
6814 Self::CHECKPOINT_FIELD,
6815 ];
6816 }
6817 impl Watermark {
6818 pub fn path_builder() -> WatermarkFieldPathBuilder {
6819 WatermarkFieldPathBuilder::new()
6820 }
6821 }
6822 pub struct WatermarkFieldPathBuilder {
6823 path: Vec<&'static str>,
6824 }
6825 impl WatermarkFieldPathBuilder {
6826 #[allow(clippy::new_without_default)]
6827 pub fn new() -> Self {
6828 Self { path: Default::default() }
6829 }
6830 #[doc(hidden)]
6831 pub fn new_with_base(base: Vec<&'static str>) -> Self {
6832 Self { path: base }
6833 }
6834 pub fn finish(self) -> String {
6835 self.path.join(".")
6836 }
6837 pub fn cursor(mut self) -> String {
6838 self.path.push(Watermark::CURSOR_FIELD.name);
6839 self.finish()
6840 }
6841 pub fn checkpoint(mut self) -> String {
6842 self.path.push(Watermark::CHECKPOINT_FIELD.name);
6843 self.finish()
6844 }
6845 }
6846 impl QueryEnd {
6847 pub const REASON_FIELD: &'static MessageField = &MessageField {
6848 name: "reason",
6849 json_name: "reason",
6850 number: 1i32,
6851 message_fields: None,
6852 };
6853 }
6854 impl MessageFields for QueryEnd {
6855 const FIELDS: &'static [&'static MessageField] = &[Self::REASON_FIELD];
6856 }
6857 impl QueryEnd {
6858 pub fn path_builder() -> QueryEndFieldPathBuilder {
6859 QueryEndFieldPathBuilder::new()
6860 }
6861 }
6862 pub struct QueryEndFieldPathBuilder {
6863 path: Vec<&'static str>,
6864 }
6865 impl QueryEndFieldPathBuilder {
6866 #[allow(clippy::new_without_default)]
6867 pub fn new() -> Self {
6868 Self { path: Default::default() }
6869 }
6870 #[doc(hidden)]
6871 pub fn new_with_base(base: Vec<&'static str>) -> Self {
6872 Self { path: base }
6873 }
6874 pub fn finish(self) -> String {
6875 self.path.join(".")
6876 }
6877 pub fn reason(mut self) -> String {
6878 self.path.push(QueryEnd::REASON_FIELD.name);
6879 self.finish()
6880 }
6881 }
6882 impl UserSignature {
6883 pub const BCS_FIELD: &'static MessageField = &MessageField {
6884 name: "bcs",
6885 json_name: "bcs",
6886 number: 1i32,
6887 message_fields: Some(Bcs::FIELDS),
6888 };
6889 pub const SCHEME_FIELD: &'static MessageField = &MessageField {
6890 name: "scheme",
6891 json_name: "scheme",
6892 number: 2i32,
6893 message_fields: None,
6894 };
6895 pub const SIMPLE_FIELD: &'static MessageField = &MessageField {
6896 name: "simple",
6897 json_name: "simple",
6898 number: 3i32,
6899 message_fields: Some(SimpleSignature::FIELDS),
6900 };
6901 pub const MULTISIG_FIELD: &'static MessageField = &MessageField {
6902 name: "multisig",
6903 json_name: "multisig",
6904 number: 4i32,
6905 message_fields: Some(MultisigAggregatedSignature::FIELDS),
6906 };
6907 pub const ZKLOGIN_FIELD: &'static MessageField = &MessageField {
6908 name: "zklogin",
6909 json_name: "zklogin",
6910 number: 5i32,
6911 message_fields: Some(ZkLoginAuthenticator::FIELDS),
6912 };
6913 pub const PASSKEY_FIELD: &'static MessageField = &MessageField {
6914 name: "passkey",
6915 json_name: "passkey",
6916 number: 6i32,
6917 message_fields: Some(PasskeyAuthenticator::FIELDS),
6918 };
6919 }
6920 impl MessageFields for UserSignature {
6921 const FIELDS: &'static [&'static MessageField] = &[
6922 Self::BCS_FIELD,
6923 Self::SCHEME_FIELD,
6924 Self::SIMPLE_FIELD,
6925 Self::MULTISIG_FIELD,
6926 Self::ZKLOGIN_FIELD,
6927 Self::PASSKEY_FIELD,
6928 ];
6929 }
6930 impl UserSignature {
6931 pub fn path_builder() -> UserSignatureFieldPathBuilder {
6932 UserSignatureFieldPathBuilder::new()
6933 }
6934 }
6935 pub struct UserSignatureFieldPathBuilder {
6936 path: Vec<&'static str>,
6937 }
6938 impl UserSignatureFieldPathBuilder {
6939 #[allow(clippy::new_without_default)]
6940 pub fn new() -> Self {
6941 Self { path: Default::default() }
6942 }
6943 #[doc(hidden)]
6944 pub fn new_with_base(base: Vec<&'static str>) -> Self {
6945 Self { path: base }
6946 }
6947 pub fn finish(self) -> String {
6948 self.path.join(".")
6949 }
6950 pub fn bcs(mut self) -> BcsFieldPathBuilder {
6951 self.path.push(UserSignature::BCS_FIELD.name);
6952 BcsFieldPathBuilder::new_with_base(self.path)
6953 }
6954 pub fn scheme(mut self) -> String {
6955 self.path.push(UserSignature::SCHEME_FIELD.name);
6956 self.finish()
6957 }
6958 pub fn simple(mut self) -> SimpleSignatureFieldPathBuilder {
6959 self.path.push(UserSignature::SIMPLE_FIELD.name);
6960 SimpleSignatureFieldPathBuilder::new_with_base(self.path)
6961 }
6962 pub fn multisig(mut self) -> MultisigAggregatedSignatureFieldPathBuilder {
6963 self.path.push(UserSignature::MULTISIG_FIELD.name);
6964 MultisigAggregatedSignatureFieldPathBuilder::new_with_base(self.path)
6965 }
6966 pub fn zklogin(mut self) -> ZkLoginAuthenticatorFieldPathBuilder {
6967 self.path.push(UserSignature::ZKLOGIN_FIELD.name);
6968 ZkLoginAuthenticatorFieldPathBuilder::new_with_base(self.path)
6969 }
6970 pub fn passkey(mut self) -> PasskeyAuthenticatorFieldPathBuilder {
6971 self.path.push(UserSignature::PASSKEY_FIELD.name);
6972 PasskeyAuthenticatorFieldPathBuilder::new_with_base(self.path)
6973 }
6974 }
6975 impl SimpleSignature {
6976 pub const SCHEME_FIELD: &'static MessageField = &MessageField {
6977 name: "scheme",
6978 json_name: "scheme",
6979 number: 1i32,
6980 message_fields: None,
6981 };
6982 pub const SIGNATURE_FIELD: &'static MessageField = &MessageField {
6983 name: "signature",
6984 json_name: "signature",
6985 number: 2i32,
6986 message_fields: None,
6987 };
6988 pub const PUBLIC_KEY_FIELD: &'static MessageField = &MessageField {
6989 name: "public_key",
6990 json_name: "publicKey",
6991 number: 3i32,
6992 message_fields: None,
6993 };
6994 }
6995 impl MessageFields for SimpleSignature {
6996 const FIELDS: &'static [&'static MessageField] = &[
6997 Self::SCHEME_FIELD,
6998 Self::SIGNATURE_FIELD,
6999 Self::PUBLIC_KEY_FIELD,
7000 ];
7001 }
7002 impl SimpleSignature {
7003 pub fn path_builder() -> SimpleSignatureFieldPathBuilder {
7004 SimpleSignatureFieldPathBuilder::new()
7005 }
7006 }
7007 pub struct SimpleSignatureFieldPathBuilder {
7008 path: Vec<&'static str>,
7009 }
7010 impl SimpleSignatureFieldPathBuilder {
7011 #[allow(clippy::new_without_default)]
7012 pub fn new() -> Self {
7013 Self { path: Default::default() }
7014 }
7015 #[doc(hidden)]
7016 pub fn new_with_base(base: Vec<&'static str>) -> Self {
7017 Self { path: base }
7018 }
7019 pub fn finish(self) -> String {
7020 self.path.join(".")
7021 }
7022 pub fn scheme(mut self) -> String {
7023 self.path.push(SimpleSignature::SCHEME_FIELD.name);
7024 self.finish()
7025 }
7026 pub fn signature(mut self) -> String {
7027 self.path.push(SimpleSignature::SIGNATURE_FIELD.name);
7028 self.finish()
7029 }
7030 pub fn public_key(mut self) -> String {
7031 self.path.push(SimpleSignature::PUBLIC_KEY_FIELD.name);
7032 self.finish()
7033 }
7034 }
7035 impl ZkLoginPublicIdentifier {
7036 pub const ISS_FIELD: &'static MessageField = &MessageField {
7037 name: "iss",
7038 json_name: "iss",
7039 number: 1i32,
7040 message_fields: None,
7041 };
7042 pub const ADDRESS_SEED_FIELD: &'static MessageField = &MessageField {
7043 name: "address_seed",
7044 json_name: "addressSeed",
7045 number: 2i32,
7046 message_fields: None,
7047 };
7048 }
7049 impl MessageFields for ZkLoginPublicIdentifier {
7050 const FIELDS: &'static [&'static MessageField] = &[
7051 Self::ISS_FIELD,
7052 Self::ADDRESS_SEED_FIELD,
7053 ];
7054 }
7055 impl ZkLoginPublicIdentifier {
7056 pub fn path_builder() -> ZkLoginPublicIdentifierFieldPathBuilder {
7057 ZkLoginPublicIdentifierFieldPathBuilder::new()
7058 }
7059 }
7060 pub struct ZkLoginPublicIdentifierFieldPathBuilder {
7061 path: Vec<&'static str>,
7062 }
7063 impl ZkLoginPublicIdentifierFieldPathBuilder {
7064 #[allow(clippy::new_without_default)]
7065 pub fn new() -> Self {
7066 Self { path: Default::default() }
7067 }
7068 #[doc(hidden)]
7069 pub fn new_with_base(base: Vec<&'static str>) -> Self {
7070 Self { path: base }
7071 }
7072 pub fn finish(self) -> String {
7073 self.path.join(".")
7074 }
7075 pub fn iss(mut self) -> String {
7076 self.path.push(ZkLoginPublicIdentifier::ISS_FIELD.name);
7077 self.finish()
7078 }
7079 pub fn address_seed(mut self) -> String {
7080 self.path.push(ZkLoginPublicIdentifier::ADDRESS_SEED_FIELD.name);
7081 self.finish()
7082 }
7083 }
7084 impl MultisigMemberPublicKey {
7085 pub const SCHEME_FIELD: &'static MessageField = &MessageField {
7086 name: "scheme",
7087 json_name: "scheme",
7088 number: 1i32,
7089 message_fields: None,
7090 };
7091 pub const PUBLIC_KEY_FIELD: &'static MessageField = &MessageField {
7092 name: "public_key",
7093 json_name: "publicKey",
7094 number: 2i32,
7095 message_fields: None,
7096 };
7097 pub const ZKLOGIN_FIELD: &'static MessageField = &MessageField {
7098 name: "zklogin",
7099 json_name: "zklogin",
7100 number: 3i32,
7101 message_fields: Some(ZkLoginPublicIdentifier::FIELDS),
7102 };
7103 }
7104 impl MessageFields for MultisigMemberPublicKey {
7105 const FIELDS: &'static [&'static MessageField] = &[
7106 Self::SCHEME_FIELD,
7107 Self::PUBLIC_KEY_FIELD,
7108 Self::ZKLOGIN_FIELD,
7109 ];
7110 }
7111 impl MultisigMemberPublicKey {
7112 pub fn path_builder() -> MultisigMemberPublicKeyFieldPathBuilder {
7113 MultisigMemberPublicKeyFieldPathBuilder::new()
7114 }
7115 }
7116 pub struct MultisigMemberPublicKeyFieldPathBuilder {
7117 path: Vec<&'static str>,
7118 }
7119 impl MultisigMemberPublicKeyFieldPathBuilder {
7120 #[allow(clippy::new_without_default)]
7121 pub fn new() -> Self {
7122 Self { path: Default::default() }
7123 }
7124 #[doc(hidden)]
7125 pub fn new_with_base(base: Vec<&'static str>) -> Self {
7126 Self { path: base }
7127 }
7128 pub fn finish(self) -> String {
7129 self.path.join(".")
7130 }
7131 pub fn scheme(mut self) -> String {
7132 self.path.push(MultisigMemberPublicKey::SCHEME_FIELD.name);
7133 self.finish()
7134 }
7135 pub fn public_key(mut self) -> String {
7136 self.path.push(MultisigMemberPublicKey::PUBLIC_KEY_FIELD.name);
7137 self.finish()
7138 }
7139 pub fn zklogin(mut self) -> ZkLoginPublicIdentifierFieldPathBuilder {
7140 self.path.push(MultisigMemberPublicKey::ZKLOGIN_FIELD.name);
7141 ZkLoginPublicIdentifierFieldPathBuilder::new_with_base(self.path)
7142 }
7143 }
7144 impl MultisigMember {
7145 pub const PUBLIC_KEY_FIELD: &'static MessageField = &MessageField {
7146 name: "public_key",
7147 json_name: "publicKey",
7148 number: 1i32,
7149 message_fields: Some(MultisigMemberPublicKey::FIELDS),
7150 };
7151 pub const WEIGHT_FIELD: &'static MessageField = &MessageField {
7152 name: "weight",
7153 json_name: "weight",
7154 number: 2i32,
7155 message_fields: None,
7156 };
7157 }
7158 impl MessageFields for MultisigMember {
7159 const FIELDS: &'static [&'static MessageField] = &[
7160 Self::PUBLIC_KEY_FIELD,
7161 Self::WEIGHT_FIELD,
7162 ];
7163 }
7164 impl MultisigMember {
7165 pub fn path_builder() -> MultisigMemberFieldPathBuilder {
7166 MultisigMemberFieldPathBuilder::new()
7167 }
7168 }
7169 pub struct MultisigMemberFieldPathBuilder {
7170 path: Vec<&'static str>,
7171 }
7172 impl MultisigMemberFieldPathBuilder {
7173 #[allow(clippy::new_without_default)]
7174 pub fn new() -> Self {
7175 Self { path: Default::default() }
7176 }
7177 #[doc(hidden)]
7178 pub fn new_with_base(base: Vec<&'static str>) -> Self {
7179 Self { path: base }
7180 }
7181 pub fn finish(self) -> String {
7182 self.path.join(".")
7183 }
7184 pub fn public_key(mut self) -> MultisigMemberPublicKeyFieldPathBuilder {
7185 self.path.push(MultisigMember::PUBLIC_KEY_FIELD.name);
7186 MultisigMemberPublicKeyFieldPathBuilder::new_with_base(self.path)
7187 }
7188 pub fn weight(mut self) -> String {
7189 self.path.push(MultisigMember::WEIGHT_FIELD.name);
7190 self.finish()
7191 }
7192 }
7193 impl MultisigCommittee {
7194 pub const MEMBERS_FIELD: &'static MessageField = &MessageField {
7195 name: "members",
7196 json_name: "members",
7197 number: 1i32,
7198 message_fields: Some(MultisigMember::FIELDS),
7199 };
7200 pub const THRESHOLD_FIELD: &'static MessageField = &MessageField {
7201 name: "threshold",
7202 json_name: "threshold",
7203 number: 2i32,
7204 message_fields: None,
7205 };
7206 }
7207 impl MessageFields for MultisigCommittee {
7208 const FIELDS: &'static [&'static MessageField] = &[
7209 Self::MEMBERS_FIELD,
7210 Self::THRESHOLD_FIELD,
7211 ];
7212 }
7213 impl MultisigCommittee {
7214 pub fn path_builder() -> MultisigCommitteeFieldPathBuilder {
7215 MultisigCommitteeFieldPathBuilder::new()
7216 }
7217 }
7218 pub struct MultisigCommitteeFieldPathBuilder {
7219 path: Vec<&'static str>,
7220 }
7221 impl MultisigCommitteeFieldPathBuilder {
7222 #[allow(clippy::new_without_default)]
7223 pub fn new() -> Self {
7224 Self { path: Default::default() }
7225 }
7226 #[doc(hidden)]
7227 pub fn new_with_base(base: Vec<&'static str>) -> Self {
7228 Self { path: base }
7229 }
7230 pub fn finish(self) -> String {
7231 self.path.join(".")
7232 }
7233 pub fn members(mut self) -> MultisigMemberFieldPathBuilder {
7234 self.path.push(MultisigCommittee::MEMBERS_FIELD.name);
7235 MultisigMemberFieldPathBuilder::new_with_base(self.path)
7236 }
7237 pub fn threshold(mut self) -> String {
7238 self.path.push(MultisigCommittee::THRESHOLD_FIELD.name);
7239 self.finish()
7240 }
7241 }
7242 impl MultisigAggregatedSignature {
7243 pub const SIGNATURES_FIELD: &'static MessageField = &MessageField {
7244 name: "signatures",
7245 json_name: "signatures",
7246 number: 1i32,
7247 message_fields: Some(MultisigMemberSignature::FIELDS),
7248 };
7249 pub const BITMAP_FIELD: &'static MessageField = &MessageField {
7250 name: "bitmap",
7251 json_name: "bitmap",
7252 number: 2i32,
7253 message_fields: None,
7254 };
7255 pub const LEGACY_BITMAP_FIELD: &'static MessageField = &MessageField {
7256 name: "legacy_bitmap",
7257 json_name: "legacyBitmap",
7258 number: 3i32,
7259 message_fields: None,
7260 };
7261 pub const COMMITTEE_FIELD: &'static MessageField = &MessageField {
7262 name: "committee",
7263 json_name: "committee",
7264 number: 4i32,
7265 message_fields: Some(MultisigCommittee::FIELDS),
7266 };
7267 }
7268 impl MessageFields for MultisigAggregatedSignature {
7269 const FIELDS: &'static [&'static MessageField] = &[
7270 Self::SIGNATURES_FIELD,
7271 Self::BITMAP_FIELD,
7272 Self::LEGACY_BITMAP_FIELD,
7273 Self::COMMITTEE_FIELD,
7274 ];
7275 }
7276 impl MultisigAggregatedSignature {
7277 pub fn path_builder() -> MultisigAggregatedSignatureFieldPathBuilder {
7278 MultisigAggregatedSignatureFieldPathBuilder::new()
7279 }
7280 }
7281 pub struct MultisigAggregatedSignatureFieldPathBuilder {
7282 path: Vec<&'static str>,
7283 }
7284 impl MultisigAggregatedSignatureFieldPathBuilder {
7285 #[allow(clippy::new_without_default)]
7286 pub fn new() -> Self {
7287 Self { path: Default::default() }
7288 }
7289 #[doc(hidden)]
7290 pub fn new_with_base(base: Vec<&'static str>) -> Self {
7291 Self { path: base }
7292 }
7293 pub fn finish(self) -> String {
7294 self.path.join(".")
7295 }
7296 pub fn signatures(mut self) -> MultisigMemberSignatureFieldPathBuilder {
7297 self.path.push(MultisigAggregatedSignature::SIGNATURES_FIELD.name);
7298 MultisigMemberSignatureFieldPathBuilder::new_with_base(self.path)
7299 }
7300 pub fn bitmap(mut self) -> String {
7301 self.path.push(MultisigAggregatedSignature::BITMAP_FIELD.name);
7302 self.finish()
7303 }
7304 pub fn legacy_bitmap(mut self) -> String {
7305 self.path.push(MultisigAggregatedSignature::LEGACY_BITMAP_FIELD.name);
7306 self.finish()
7307 }
7308 pub fn committee(mut self) -> MultisigCommitteeFieldPathBuilder {
7309 self.path.push(MultisigAggregatedSignature::COMMITTEE_FIELD.name);
7310 MultisigCommitteeFieldPathBuilder::new_with_base(self.path)
7311 }
7312 }
7313 impl MultisigMemberSignature {
7314 pub const SCHEME_FIELD: &'static MessageField = &MessageField {
7315 name: "scheme",
7316 json_name: "scheme",
7317 number: 1i32,
7318 message_fields: None,
7319 };
7320 pub const SIGNATURE_FIELD: &'static MessageField = &MessageField {
7321 name: "signature",
7322 json_name: "signature",
7323 number: 2i32,
7324 message_fields: None,
7325 };
7326 pub const ZKLOGIN_FIELD: &'static MessageField = &MessageField {
7327 name: "zklogin",
7328 json_name: "zklogin",
7329 number: 3i32,
7330 message_fields: Some(ZkLoginAuthenticator::FIELDS),
7331 };
7332 pub const PASSKEY_FIELD: &'static MessageField = &MessageField {
7333 name: "passkey",
7334 json_name: "passkey",
7335 number: 4i32,
7336 message_fields: Some(PasskeyAuthenticator::FIELDS),
7337 };
7338 }
7339 impl MessageFields for MultisigMemberSignature {
7340 const FIELDS: &'static [&'static MessageField] = &[
7341 Self::SCHEME_FIELD,
7342 Self::SIGNATURE_FIELD,
7343 Self::ZKLOGIN_FIELD,
7344 Self::PASSKEY_FIELD,
7345 ];
7346 }
7347 impl MultisigMemberSignature {
7348 pub fn path_builder() -> MultisigMemberSignatureFieldPathBuilder {
7349 MultisigMemberSignatureFieldPathBuilder::new()
7350 }
7351 }
7352 pub struct MultisigMemberSignatureFieldPathBuilder {
7353 path: Vec<&'static str>,
7354 }
7355 impl MultisigMemberSignatureFieldPathBuilder {
7356 #[allow(clippy::new_without_default)]
7357 pub fn new() -> Self {
7358 Self { path: Default::default() }
7359 }
7360 #[doc(hidden)]
7361 pub fn new_with_base(base: Vec<&'static str>) -> Self {
7362 Self { path: base }
7363 }
7364 pub fn finish(self) -> String {
7365 self.path.join(".")
7366 }
7367 pub fn scheme(mut self) -> String {
7368 self.path.push(MultisigMemberSignature::SCHEME_FIELD.name);
7369 self.finish()
7370 }
7371 pub fn signature(mut self) -> String {
7372 self.path.push(MultisigMemberSignature::SIGNATURE_FIELD.name);
7373 self.finish()
7374 }
7375 pub fn zklogin(mut self) -> ZkLoginAuthenticatorFieldPathBuilder {
7376 self.path.push(MultisigMemberSignature::ZKLOGIN_FIELD.name);
7377 ZkLoginAuthenticatorFieldPathBuilder::new_with_base(self.path)
7378 }
7379 pub fn passkey(mut self) -> PasskeyAuthenticatorFieldPathBuilder {
7380 self.path.push(MultisigMemberSignature::PASSKEY_FIELD.name);
7381 PasskeyAuthenticatorFieldPathBuilder::new_with_base(self.path)
7382 }
7383 }
7384 impl ZkLoginAuthenticator {
7385 pub const INPUTS_FIELD: &'static MessageField = &MessageField {
7386 name: "inputs",
7387 json_name: "inputs",
7388 number: 1i32,
7389 message_fields: Some(ZkLoginInputs::FIELDS),
7390 };
7391 pub const MAX_EPOCH_FIELD: &'static MessageField = &MessageField {
7392 name: "max_epoch",
7393 json_name: "maxEpoch",
7394 number: 2i32,
7395 message_fields: None,
7396 };
7397 pub const SIGNATURE_FIELD: &'static MessageField = &MessageField {
7398 name: "signature",
7399 json_name: "signature",
7400 number: 3i32,
7401 message_fields: Some(SimpleSignature::FIELDS),
7402 };
7403 pub const PUBLIC_IDENTIFIER_FIELD: &'static MessageField = &MessageField {
7404 name: "public_identifier",
7405 json_name: "publicIdentifier",
7406 number: 4i32,
7407 message_fields: Some(ZkLoginPublicIdentifier::FIELDS),
7408 };
7409 pub const JWK_ID_FIELD: &'static MessageField = &MessageField {
7410 name: "jwk_id",
7411 json_name: "jwkId",
7412 number: 5i32,
7413 message_fields: Some(JwkId::FIELDS),
7414 };
7415 }
7416 impl MessageFields for ZkLoginAuthenticator {
7417 const FIELDS: &'static [&'static MessageField] = &[
7418 Self::INPUTS_FIELD,
7419 Self::MAX_EPOCH_FIELD,
7420 Self::SIGNATURE_FIELD,
7421 Self::PUBLIC_IDENTIFIER_FIELD,
7422 Self::JWK_ID_FIELD,
7423 ];
7424 }
7425 impl ZkLoginAuthenticator {
7426 pub fn path_builder() -> ZkLoginAuthenticatorFieldPathBuilder {
7427 ZkLoginAuthenticatorFieldPathBuilder::new()
7428 }
7429 }
7430 pub struct ZkLoginAuthenticatorFieldPathBuilder {
7431 path: Vec<&'static str>,
7432 }
7433 impl ZkLoginAuthenticatorFieldPathBuilder {
7434 #[allow(clippy::new_without_default)]
7435 pub fn new() -> Self {
7436 Self { path: Default::default() }
7437 }
7438 #[doc(hidden)]
7439 pub fn new_with_base(base: Vec<&'static str>) -> Self {
7440 Self { path: base }
7441 }
7442 pub fn finish(self) -> String {
7443 self.path.join(".")
7444 }
7445 pub fn inputs(mut self) -> ZkLoginInputsFieldPathBuilder {
7446 self.path.push(ZkLoginAuthenticator::INPUTS_FIELD.name);
7447 ZkLoginInputsFieldPathBuilder::new_with_base(self.path)
7448 }
7449 pub fn max_epoch(mut self) -> String {
7450 self.path.push(ZkLoginAuthenticator::MAX_EPOCH_FIELD.name);
7451 self.finish()
7452 }
7453 pub fn signature(mut self) -> SimpleSignatureFieldPathBuilder {
7454 self.path.push(ZkLoginAuthenticator::SIGNATURE_FIELD.name);
7455 SimpleSignatureFieldPathBuilder::new_with_base(self.path)
7456 }
7457 pub fn public_identifier(mut self) -> ZkLoginPublicIdentifierFieldPathBuilder {
7458 self.path.push(ZkLoginAuthenticator::PUBLIC_IDENTIFIER_FIELD.name);
7459 ZkLoginPublicIdentifierFieldPathBuilder::new_with_base(self.path)
7460 }
7461 pub fn jwk_id(mut self) -> JwkIdFieldPathBuilder {
7462 self.path.push(ZkLoginAuthenticator::JWK_ID_FIELD.name);
7463 JwkIdFieldPathBuilder::new_with_base(self.path)
7464 }
7465 }
7466 impl ZkLoginInputs {
7467 pub const PROOF_POINTS_FIELD: &'static MessageField = &MessageField {
7468 name: "proof_points",
7469 json_name: "proofPoints",
7470 number: 1i32,
7471 message_fields: Some(ZkLoginProof::FIELDS),
7472 };
7473 pub const ISS_BASE64_DETAILS_FIELD: &'static MessageField = &MessageField {
7474 name: "iss_base64_details",
7475 json_name: "issBase64Details",
7476 number: 2i32,
7477 message_fields: Some(ZkLoginClaim::FIELDS),
7478 };
7479 pub const HEADER_BASE64_FIELD: &'static MessageField = &MessageField {
7480 name: "header_base64",
7481 json_name: "headerBase64",
7482 number: 3i32,
7483 message_fields: None,
7484 };
7485 pub const ADDRESS_SEED_FIELD: &'static MessageField = &MessageField {
7486 name: "address_seed",
7487 json_name: "addressSeed",
7488 number: 4i32,
7489 message_fields: None,
7490 };
7491 }
7492 impl MessageFields for ZkLoginInputs {
7493 const FIELDS: &'static [&'static MessageField] = &[
7494 Self::PROOF_POINTS_FIELD,
7495 Self::ISS_BASE64_DETAILS_FIELD,
7496 Self::HEADER_BASE64_FIELD,
7497 Self::ADDRESS_SEED_FIELD,
7498 ];
7499 }
7500 impl ZkLoginInputs {
7501 pub fn path_builder() -> ZkLoginInputsFieldPathBuilder {
7502 ZkLoginInputsFieldPathBuilder::new()
7503 }
7504 }
7505 pub struct ZkLoginInputsFieldPathBuilder {
7506 path: Vec<&'static str>,
7507 }
7508 impl ZkLoginInputsFieldPathBuilder {
7509 #[allow(clippy::new_without_default)]
7510 pub fn new() -> Self {
7511 Self { path: Default::default() }
7512 }
7513 #[doc(hidden)]
7514 pub fn new_with_base(base: Vec<&'static str>) -> Self {
7515 Self { path: base }
7516 }
7517 pub fn finish(self) -> String {
7518 self.path.join(".")
7519 }
7520 pub fn proof_points(mut self) -> ZkLoginProofFieldPathBuilder {
7521 self.path.push(ZkLoginInputs::PROOF_POINTS_FIELD.name);
7522 ZkLoginProofFieldPathBuilder::new_with_base(self.path)
7523 }
7524 pub fn iss_base64_details(mut self) -> ZkLoginClaimFieldPathBuilder {
7525 self.path.push(ZkLoginInputs::ISS_BASE64_DETAILS_FIELD.name);
7526 ZkLoginClaimFieldPathBuilder::new_with_base(self.path)
7527 }
7528 pub fn header_base64(mut self) -> String {
7529 self.path.push(ZkLoginInputs::HEADER_BASE64_FIELD.name);
7530 self.finish()
7531 }
7532 pub fn address_seed(mut self) -> String {
7533 self.path.push(ZkLoginInputs::ADDRESS_SEED_FIELD.name);
7534 self.finish()
7535 }
7536 }
7537 impl ZkLoginProof {
7538 pub const A_FIELD: &'static MessageField = &MessageField {
7539 name: "a",
7540 json_name: "a",
7541 number: 1i32,
7542 message_fields: Some(CircomG1::FIELDS),
7543 };
7544 pub const B_FIELD: &'static MessageField = &MessageField {
7545 name: "b",
7546 json_name: "b",
7547 number: 2i32,
7548 message_fields: Some(CircomG2::FIELDS),
7549 };
7550 pub const C_FIELD: &'static MessageField = &MessageField {
7551 name: "c",
7552 json_name: "c",
7553 number: 3i32,
7554 message_fields: Some(CircomG1::FIELDS),
7555 };
7556 }
7557 impl MessageFields for ZkLoginProof {
7558 const FIELDS: &'static [&'static MessageField] = &[
7559 Self::A_FIELD,
7560 Self::B_FIELD,
7561 Self::C_FIELD,
7562 ];
7563 }
7564 impl ZkLoginProof {
7565 pub fn path_builder() -> ZkLoginProofFieldPathBuilder {
7566 ZkLoginProofFieldPathBuilder::new()
7567 }
7568 }
7569 pub struct ZkLoginProofFieldPathBuilder {
7570 path: Vec<&'static str>,
7571 }
7572 impl ZkLoginProofFieldPathBuilder {
7573 #[allow(clippy::new_without_default)]
7574 pub fn new() -> Self {
7575 Self { path: Default::default() }
7576 }
7577 #[doc(hidden)]
7578 pub fn new_with_base(base: Vec<&'static str>) -> Self {
7579 Self { path: base }
7580 }
7581 pub fn finish(self) -> String {
7582 self.path.join(".")
7583 }
7584 pub fn a(mut self) -> CircomG1FieldPathBuilder {
7585 self.path.push(ZkLoginProof::A_FIELD.name);
7586 CircomG1FieldPathBuilder::new_with_base(self.path)
7587 }
7588 pub fn b(mut self) -> CircomG2FieldPathBuilder {
7589 self.path.push(ZkLoginProof::B_FIELD.name);
7590 CircomG2FieldPathBuilder::new_with_base(self.path)
7591 }
7592 pub fn c(mut self) -> CircomG1FieldPathBuilder {
7593 self.path.push(ZkLoginProof::C_FIELD.name);
7594 CircomG1FieldPathBuilder::new_with_base(self.path)
7595 }
7596 }
7597 impl ZkLoginClaim {
7598 pub const VALUE_FIELD: &'static MessageField = &MessageField {
7599 name: "value",
7600 json_name: "value",
7601 number: 1i32,
7602 message_fields: None,
7603 };
7604 pub const INDEX_MOD_4_FIELD: &'static MessageField = &MessageField {
7605 name: "index_mod_4",
7606 json_name: "indexMod4",
7607 number: 2i32,
7608 message_fields: None,
7609 };
7610 }
7611 impl MessageFields for ZkLoginClaim {
7612 const FIELDS: &'static [&'static MessageField] = &[
7613 Self::VALUE_FIELD,
7614 Self::INDEX_MOD_4_FIELD,
7615 ];
7616 }
7617 impl ZkLoginClaim {
7618 pub fn path_builder() -> ZkLoginClaimFieldPathBuilder {
7619 ZkLoginClaimFieldPathBuilder::new()
7620 }
7621 }
7622 pub struct ZkLoginClaimFieldPathBuilder {
7623 path: Vec<&'static str>,
7624 }
7625 impl ZkLoginClaimFieldPathBuilder {
7626 #[allow(clippy::new_without_default)]
7627 pub fn new() -> Self {
7628 Self { path: Default::default() }
7629 }
7630 #[doc(hidden)]
7631 pub fn new_with_base(base: Vec<&'static str>) -> Self {
7632 Self { path: base }
7633 }
7634 pub fn finish(self) -> String {
7635 self.path.join(".")
7636 }
7637 pub fn value(mut self) -> String {
7638 self.path.push(ZkLoginClaim::VALUE_FIELD.name);
7639 self.finish()
7640 }
7641 pub fn index_mod_4(mut self) -> String {
7642 self.path.push(ZkLoginClaim::INDEX_MOD_4_FIELD.name);
7643 self.finish()
7644 }
7645 }
7646 impl CircomG1 {
7647 pub const E0_FIELD: &'static MessageField = &MessageField {
7648 name: "e0",
7649 json_name: "e0",
7650 number: 1i32,
7651 message_fields: None,
7652 };
7653 pub const E1_FIELD: &'static MessageField = &MessageField {
7654 name: "e1",
7655 json_name: "e1",
7656 number: 2i32,
7657 message_fields: None,
7658 };
7659 pub const E2_FIELD: &'static MessageField = &MessageField {
7660 name: "e2",
7661 json_name: "e2",
7662 number: 3i32,
7663 message_fields: None,
7664 };
7665 }
7666 impl MessageFields for CircomG1 {
7667 const FIELDS: &'static [&'static MessageField] = &[
7668 Self::E0_FIELD,
7669 Self::E1_FIELD,
7670 Self::E2_FIELD,
7671 ];
7672 }
7673 impl CircomG1 {
7674 pub fn path_builder() -> CircomG1FieldPathBuilder {
7675 CircomG1FieldPathBuilder::new()
7676 }
7677 }
7678 pub struct CircomG1FieldPathBuilder {
7679 path: Vec<&'static str>,
7680 }
7681 impl CircomG1FieldPathBuilder {
7682 #[allow(clippy::new_without_default)]
7683 pub fn new() -> Self {
7684 Self { path: Default::default() }
7685 }
7686 #[doc(hidden)]
7687 pub fn new_with_base(base: Vec<&'static str>) -> Self {
7688 Self { path: base }
7689 }
7690 pub fn finish(self) -> String {
7691 self.path.join(".")
7692 }
7693 pub fn e0(mut self) -> String {
7694 self.path.push(CircomG1::E0_FIELD.name);
7695 self.finish()
7696 }
7697 pub fn e1(mut self) -> String {
7698 self.path.push(CircomG1::E1_FIELD.name);
7699 self.finish()
7700 }
7701 pub fn e2(mut self) -> String {
7702 self.path.push(CircomG1::E2_FIELD.name);
7703 self.finish()
7704 }
7705 }
7706 impl CircomG2 {
7707 pub const E00_FIELD: &'static MessageField = &MessageField {
7708 name: "e00",
7709 json_name: "e00",
7710 number: 1i32,
7711 message_fields: None,
7712 };
7713 pub const E01_FIELD: &'static MessageField = &MessageField {
7714 name: "e01",
7715 json_name: "e01",
7716 number: 2i32,
7717 message_fields: None,
7718 };
7719 pub const E10_FIELD: &'static MessageField = &MessageField {
7720 name: "e10",
7721 json_name: "e10",
7722 number: 3i32,
7723 message_fields: None,
7724 };
7725 pub const E11_FIELD: &'static MessageField = &MessageField {
7726 name: "e11",
7727 json_name: "e11",
7728 number: 4i32,
7729 message_fields: None,
7730 };
7731 pub const E20_FIELD: &'static MessageField = &MessageField {
7732 name: "e20",
7733 json_name: "e20",
7734 number: 5i32,
7735 message_fields: None,
7736 };
7737 pub const E21_FIELD: &'static MessageField = &MessageField {
7738 name: "e21",
7739 json_name: "e21",
7740 number: 6i32,
7741 message_fields: None,
7742 };
7743 }
7744 impl MessageFields for CircomG2 {
7745 const FIELDS: &'static [&'static MessageField] = &[
7746 Self::E00_FIELD,
7747 Self::E01_FIELD,
7748 Self::E10_FIELD,
7749 Self::E11_FIELD,
7750 Self::E20_FIELD,
7751 Self::E21_FIELD,
7752 ];
7753 }
7754 impl CircomG2 {
7755 pub fn path_builder() -> CircomG2FieldPathBuilder {
7756 CircomG2FieldPathBuilder::new()
7757 }
7758 }
7759 pub struct CircomG2FieldPathBuilder {
7760 path: Vec<&'static str>,
7761 }
7762 impl CircomG2FieldPathBuilder {
7763 #[allow(clippy::new_without_default)]
7764 pub fn new() -> Self {
7765 Self { path: Default::default() }
7766 }
7767 #[doc(hidden)]
7768 pub fn new_with_base(base: Vec<&'static str>) -> Self {
7769 Self { path: base }
7770 }
7771 pub fn finish(self) -> String {
7772 self.path.join(".")
7773 }
7774 pub fn e00(mut self) -> String {
7775 self.path.push(CircomG2::E00_FIELD.name);
7776 self.finish()
7777 }
7778 pub fn e01(mut self) -> String {
7779 self.path.push(CircomG2::E01_FIELD.name);
7780 self.finish()
7781 }
7782 pub fn e10(mut self) -> String {
7783 self.path.push(CircomG2::E10_FIELD.name);
7784 self.finish()
7785 }
7786 pub fn e11(mut self) -> String {
7787 self.path.push(CircomG2::E11_FIELD.name);
7788 self.finish()
7789 }
7790 pub fn e20(mut self) -> String {
7791 self.path.push(CircomG2::E20_FIELD.name);
7792 self.finish()
7793 }
7794 pub fn e21(mut self) -> String {
7795 self.path.push(CircomG2::E21_FIELD.name);
7796 self.finish()
7797 }
7798 }
7799 impl PasskeyAuthenticator {
7800 pub const AUTHENTICATOR_DATA_FIELD: &'static MessageField = &MessageField {
7801 name: "authenticator_data",
7802 json_name: "authenticatorData",
7803 number: 1i32,
7804 message_fields: None,
7805 };
7806 pub const CLIENT_DATA_JSON_FIELD: &'static MessageField = &MessageField {
7807 name: "client_data_json",
7808 json_name: "clientDataJson",
7809 number: 2i32,
7810 message_fields: None,
7811 };
7812 pub const SIGNATURE_FIELD: &'static MessageField = &MessageField {
7813 name: "signature",
7814 json_name: "signature",
7815 number: 3i32,
7816 message_fields: Some(SimpleSignature::FIELDS),
7817 };
7818 }
7819 impl MessageFields for PasskeyAuthenticator {
7820 const FIELDS: &'static [&'static MessageField] = &[
7821 Self::AUTHENTICATOR_DATA_FIELD,
7822 Self::CLIENT_DATA_JSON_FIELD,
7823 Self::SIGNATURE_FIELD,
7824 ];
7825 }
7826 impl PasskeyAuthenticator {
7827 pub fn path_builder() -> PasskeyAuthenticatorFieldPathBuilder {
7828 PasskeyAuthenticatorFieldPathBuilder::new()
7829 }
7830 }
7831 pub struct PasskeyAuthenticatorFieldPathBuilder {
7832 path: Vec<&'static str>,
7833 }
7834 impl PasskeyAuthenticatorFieldPathBuilder {
7835 #[allow(clippy::new_without_default)]
7836 pub fn new() -> Self {
7837 Self { path: Default::default() }
7838 }
7839 #[doc(hidden)]
7840 pub fn new_with_base(base: Vec<&'static str>) -> Self {
7841 Self { path: base }
7842 }
7843 pub fn finish(self) -> String {
7844 self.path.join(".")
7845 }
7846 pub fn authenticator_data(mut self) -> String {
7847 self.path.push(PasskeyAuthenticator::AUTHENTICATOR_DATA_FIELD.name);
7848 self.finish()
7849 }
7850 pub fn client_data_json(mut self) -> String {
7851 self.path.push(PasskeyAuthenticator::CLIENT_DATA_JSON_FIELD.name);
7852 self.finish()
7853 }
7854 pub fn signature(mut self) -> SimpleSignatureFieldPathBuilder {
7855 self.path.push(PasskeyAuthenticator::SIGNATURE_FIELD.name);
7856 SimpleSignatureFieldPathBuilder::new_with_base(self.path)
7857 }
7858 }
7859 impl ValidatorCommittee {
7860 pub const EPOCH_FIELD: &'static MessageField = &MessageField {
7861 name: "epoch",
7862 json_name: "epoch",
7863 number: 1i32,
7864 message_fields: None,
7865 };
7866 pub const MEMBERS_FIELD: &'static MessageField = &MessageField {
7867 name: "members",
7868 json_name: "members",
7869 number: 2i32,
7870 message_fields: Some(ValidatorCommitteeMember::FIELDS),
7871 };
7872 }
7873 impl MessageFields for ValidatorCommittee {
7874 const FIELDS: &'static [&'static MessageField] = &[
7875 Self::EPOCH_FIELD,
7876 Self::MEMBERS_FIELD,
7877 ];
7878 }
7879 impl ValidatorCommittee {
7880 pub fn path_builder() -> ValidatorCommitteeFieldPathBuilder {
7881 ValidatorCommitteeFieldPathBuilder::new()
7882 }
7883 }
7884 pub struct ValidatorCommitteeFieldPathBuilder {
7885 path: Vec<&'static str>,
7886 }
7887 impl ValidatorCommitteeFieldPathBuilder {
7888 #[allow(clippy::new_without_default)]
7889 pub fn new() -> Self {
7890 Self { path: Default::default() }
7891 }
7892 #[doc(hidden)]
7893 pub fn new_with_base(base: Vec<&'static str>) -> Self {
7894 Self { path: base }
7895 }
7896 pub fn finish(self) -> String {
7897 self.path.join(".")
7898 }
7899 pub fn epoch(mut self) -> String {
7900 self.path.push(ValidatorCommittee::EPOCH_FIELD.name);
7901 self.finish()
7902 }
7903 pub fn members(mut self) -> ValidatorCommitteeMemberFieldPathBuilder {
7904 self.path.push(ValidatorCommittee::MEMBERS_FIELD.name);
7905 ValidatorCommitteeMemberFieldPathBuilder::new_with_base(self.path)
7906 }
7907 }
7908 impl ValidatorCommitteeMember {
7909 pub const PUBLIC_KEY_FIELD: &'static MessageField = &MessageField {
7910 name: "public_key",
7911 json_name: "publicKey",
7912 number: 1i32,
7913 message_fields: None,
7914 };
7915 pub const WEIGHT_FIELD: &'static MessageField = &MessageField {
7916 name: "weight",
7917 json_name: "weight",
7918 number: 2i32,
7919 message_fields: None,
7920 };
7921 }
7922 impl MessageFields for ValidatorCommitteeMember {
7923 const FIELDS: &'static [&'static MessageField] = &[
7924 Self::PUBLIC_KEY_FIELD,
7925 Self::WEIGHT_FIELD,
7926 ];
7927 }
7928 impl ValidatorCommitteeMember {
7929 pub fn path_builder() -> ValidatorCommitteeMemberFieldPathBuilder {
7930 ValidatorCommitteeMemberFieldPathBuilder::new()
7931 }
7932 }
7933 pub struct ValidatorCommitteeMemberFieldPathBuilder {
7934 path: Vec<&'static str>,
7935 }
7936 impl ValidatorCommitteeMemberFieldPathBuilder {
7937 #[allow(clippy::new_without_default)]
7938 pub fn new() -> Self {
7939 Self { path: Default::default() }
7940 }
7941 #[doc(hidden)]
7942 pub fn new_with_base(base: Vec<&'static str>) -> Self {
7943 Self { path: base }
7944 }
7945 pub fn finish(self) -> String {
7946 self.path.join(".")
7947 }
7948 pub fn public_key(mut self) -> String {
7949 self.path.push(ValidatorCommitteeMember::PUBLIC_KEY_FIELD.name);
7950 self.finish()
7951 }
7952 pub fn weight(mut self) -> String {
7953 self.path.push(ValidatorCommitteeMember::WEIGHT_FIELD.name);
7954 self.finish()
7955 }
7956 }
7957 impl ValidatorAggregatedSignature {
7958 pub const EPOCH_FIELD: &'static MessageField = &MessageField {
7959 name: "epoch",
7960 json_name: "epoch",
7961 number: 1i32,
7962 message_fields: None,
7963 };
7964 pub const SIGNATURE_FIELD: &'static MessageField = &MessageField {
7965 name: "signature",
7966 json_name: "signature",
7967 number: 2i32,
7968 message_fields: None,
7969 };
7970 pub const BITMAP_FIELD: &'static MessageField = &MessageField {
7971 name: "bitmap",
7972 json_name: "bitmap",
7973 number: 3i32,
7974 message_fields: None,
7975 };
7976 }
7977 impl MessageFields for ValidatorAggregatedSignature {
7978 const FIELDS: &'static [&'static MessageField] = &[
7979 Self::EPOCH_FIELD,
7980 Self::SIGNATURE_FIELD,
7981 Self::BITMAP_FIELD,
7982 ];
7983 }
7984 impl ValidatorAggregatedSignature {
7985 pub fn path_builder() -> ValidatorAggregatedSignatureFieldPathBuilder {
7986 ValidatorAggregatedSignatureFieldPathBuilder::new()
7987 }
7988 }
7989 pub struct ValidatorAggregatedSignatureFieldPathBuilder {
7990 path: Vec<&'static str>,
7991 }
7992 impl ValidatorAggregatedSignatureFieldPathBuilder {
7993 #[allow(clippy::new_without_default)]
7994 pub fn new() -> Self {
7995 Self { path: Default::default() }
7996 }
7997 #[doc(hidden)]
7998 pub fn new_with_base(base: Vec<&'static str>) -> Self {
7999 Self { path: base }
8000 }
8001 pub fn finish(self) -> String {
8002 self.path.join(".")
8003 }
8004 pub fn epoch(mut self) -> String {
8005 self.path.push(ValidatorAggregatedSignature::EPOCH_FIELD.name);
8006 self.finish()
8007 }
8008 pub fn signature(mut self) -> String {
8009 self.path.push(ValidatorAggregatedSignature::SIGNATURE_FIELD.name);
8010 self.finish()
8011 }
8012 pub fn bitmap(mut self) -> String {
8013 self.path.push(ValidatorAggregatedSignature::BITMAP_FIELD.name);
8014 self.finish()
8015 }
8016 }
8017 impl VerifySignatureRequest {
8018 pub const MESSAGE_FIELD: &'static MessageField = &MessageField {
8019 name: "message",
8020 json_name: "message",
8021 number: 1i32,
8022 message_fields: Some(Bcs::FIELDS),
8023 };
8024 pub const SIGNATURE_FIELD: &'static MessageField = &MessageField {
8025 name: "signature",
8026 json_name: "signature",
8027 number: 2i32,
8028 message_fields: Some(UserSignature::FIELDS),
8029 };
8030 pub const ADDRESS_FIELD: &'static MessageField = &MessageField {
8031 name: "address",
8032 json_name: "address",
8033 number: 3i32,
8034 message_fields: None,
8035 };
8036 pub const JWKS_FIELD: &'static MessageField = &MessageField {
8037 name: "jwks",
8038 json_name: "jwks",
8039 number: 4i32,
8040 message_fields: Some(ActiveJwk::FIELDS),
8041 };
8042 }
8043 impl MessageFields for VerifySignatureRequest {
8044 const FIELDS: &'static [&'static MessageField] = &[
8045 Self::MESSAGE_FIELD,
8046 Self::SIGNATURE_FIELD,
8047 Self::ADDRESS_FIELD,
8048 Self::JWKS_FIELD,
8049 ];
8050 }
8051 impl VerifySignatureRequest {
8052 pub fn path_builder() -> VerifySignatureRequestFieldPathBuilder {
8053 VerifySignatureRequestFieldPathBuilder::new()
8054 }
8055 }
8056 pub struct VerifySignatureRequestFieldPathBuilder {
8057 path: Vec<&'static str>,
8058 }
8059 impl VerifySignatureRequestFieldPathBuilder {
8060 #[allow(clippy::new_without_default)]
8061 pub fn new() -> Self {
8062 Self { path: Default::default() }
8063 }
8064 #[doc(hidden)]
8065 pub fn new_with_base(base: Vec<&'static str>) -> Self {
8066 Self { path: base }
8067 }
8068 pub fn finish(self) -> String {
8069 self.path.join(".")
8070 }
8071 pub fn message(mut self) -> BcsFieldPathBuilder {
8072 self.path.push(VerifySignatureRequest::MESSAGE_FIELD.name);
8073 BcsFieldPathBuilder::new_with_base(self.path)
8074 }
8075 pub fn signature(mut self) -> UserSignatureFieldPathBuilder {
8076 self.path.push(VerifySignatureRequest::SIGNATURE_FIELD.name);
8077 UserSignatureFieldPathBuilder::new_with_base(self.path)
8078 }
8079 pub fn address(mut self) -> String {
8080 self.path.push(VerifySignatureRequest::ADDRESS_FIELD.name);
8081 self.finish()
8082 }
8083 pub fn jwks(mut self) -> ActiveJwkFieldPathBuilder {
8084 self.path.push(VerifySignatureRequest::JWKS_FIELD.name);
8085 ActiveJwkFieldPathBuilder::new_with_base(self.path)
8086 }
8087 }
8088 impl VerifySignatureResponse {
8089 pub const IS_VALID_FIELD: &'static MessageField = &MessageField {
8090 name: "is_valid",
8091 json_name: "isValid",
8092 number: 1i32,
8093 message_fields: None,
8094 };
8095 pub const REASON_FIELD: &'static MessageField = &MessageField {
8096 name: "reason",
8097 json_name: "reason",
8098 number: 2i32,
8099 message_fields: None,
8100 };
8101 }
8102 impl MessageFields for VerifySignatureResponse {
8103 const FIELDS: &'static [&'static MessageField] = &[
8104 Self::IS_VALID_FIELD,
8105 Self::REASON_FIELD,
8106 ];
8107 }
8108 impl VerifySignatureResponse {
8109 pub fn path_builder() -> VerifySignatureResponseFieldPathBuilder {
8110 VerifySignatureResponseFieldPathBuilder::new()
8111 }
8112 }
8113 pub struct VerifySignatureResponseFieldPathBuilder {
8114 path: Vec<&'static str>,
8115 }
8116 impl VerifySignatureResponseFieldPathBuilder {
8117 #[allow(clippy::new_without_default)]
8118 pub fn new() -> Self {
8119 Self { path: Default::default() }
8120 }
8121 #[doc(hidden)]
8122 pub fn new_with_base(base: Vec<&'static str>) -> Self {
8123 Self { path: base }
8124 }
8125 pub fn finish(self) -> String {
8126 self.path.join(".")
8127 }
8128 pub fn is_valid(mut self) -> String {
8129 self.path.push(VerifySignatureResponse::IS_VALID_FIELD.name);
8130 self.finish()
8131 }
8132 pub fn reason(mut self) -> String {
8133 self.path.push(VerifySignatureResponse::REASON_FIELD.name);
8134 self.finish()
8135 }
8136 }
8137 impl GetCoinInfoRequest {
8138 pub const COIN_TYPE_FIELD: &'static MessageField = &MessageField {
8139 name: "coin_type",
8140 json_name: "coinType",
8141 number: 1i32,
8142 message_fields: None,
8143 };
8144 }
8145 impl MessageFields for GetCoinInfoRequest {
8146 const FIELDS: &'static [&'static MessageField] = &[Self::COIN_TYPE_FIELD];
8147 }
8148 impl GetCoinInfoRequest {
8149 pub fn path_builder() -> GetCoinInfoRequestFieldPathBuilder {
8150 GetCoinInfoRequestFieldPathBuilder::new()
8151 }
8152 }
8153 pub struct GetCoinInfoRequestFieldPathBuilder {
8154 path: Vec<&'static str>,
8155 }
8156 impl GetCoinInfoRequestFieldPathBuilder {
8157 #[allow(clippy::new_without_default)]
8158 pub fn new() -> Self {
8159 Self { path: Default::default() }
8160 }
8161 #[doc(hidden)]
8162 pub fn new_with_base(base: Vec<&'static str>) -> Self {
8163 Self { path: base }
8164 }
8165 pub fn finish(self) -> String {
8166 self.path.join(".")
8167 }
8168 pub fn coin_type(mut self) -> String {
8169 self.path.push(GetCoinInfoRequest::COIN_TYPE_FIELD.name);
8170 self.finish()
8171 }
8172 }
8173 impl GetCoinInfoResponse {
8174 pub const COIN_TYPE_FIELD: &'static MessageField = &MessageField {
8175 name: "coin_type",
8176 json_name: "coinType",
8177 number: 1i32,
8178 message_fields: None,
8179 };
8180 pub const METADATA_FIELD: &'static MessageField = &MessageField {
8181 name: "metadata",
8182 json_name: "metadata",
8183 number: 2i32,
8184 message_fields: Some(CoinMetadata::FIELDS),
8185 };
8186 pub const TREASURY_FIELD: &'static MessageField = &MessageField {
8187 name: "treasury",
8188 json_name: "treasury",
8189 number: 3i32,
8190 message_fields: Some(CoinTreasury::FIELDS),
8191 };
8192 pub const REGULATED_METADATA_FIELD: &'static MessageField = &MessageField {
8193 name: "regulated_metadata",
8194 json_name: "regulatedMetadata",
8195 number: 4i32,
8196 message_fields: Some(RegulatedCoinMetadata::FIELDS),
8197 };
8198 }
8199 impl MessageFields for GetCoinInfoResponse {
8200 const FIELDS: &'static [&'static MessageField] = &[
8201 Self::COIN_TYPE_FIELD,
8202 Self::METADATA_FIELD,
8203 Self::TREASURY_FIELD,
8204 Self::REGULATED_METADATA_FIELD,
8205 ];
8206 }
8207 impl GetCoinInfoResponse {
8208 pub fn path_builder() -> GetCoinInfoResponseFieldPathBuilder {
8209 GetCoinInfoResponseFieldPathBuilder::new()
8210 }
8211 }
8212 pub struct GetCoinInfoResponseFieldPathBuilder {
8213 path: Vec<&'static str>,
8214 }
8215 impl GetCoinInfoResponseFieldPathBuilder {
8216 #[allow(clippy::new_without_default)]
8217 pub fn new() -> Self {
8218 Self { path: Default::default() }
8219 }
8220 #[doc(hidden)]
8221 pub fn new_with_base(base: Vec<&'static str>) -> Self {
8222 Self { path: base }
8223 }
8224 pub fn finish(self) -> String {
8225 self.path.join(".")
8226 }
8227 pub fn coin_type(mut self) -> String {
8228 self.path.push(GetCoinInfoResponse::COIN_TYPE_FIELD.name);
8229 self.finish()
8230 }
8231 pub fn metadata(mut self) -> CoinMetadataFieldPathBuilder {
8232 self.path.push(GetCoinInfoResponse::METADATA_FIELD.name);
8233 CoinMetadataFieldPathBuilder::new_with_base(self.path)
8234 }
8235 pub fn treasury(mut self) -> CoinTreasuryFieldPathBuilder {
8236 self.path.push(GetCoinInfoResponse::TREASURY_FIELD.name);
8237 CoinTreasuryFieldPathBuilder::new_with_base(self.path)
8238 }
8239 pub fn regulated_metadata(mut self) -> RegulatedCoinMetadataFieldPathBuilder {
8240 self.path.push(GetCoinInfoResponse::REGULATED_METADATA_FIELD.name);
8241 RegulatedCoinMetadataFieldPathBuilder::new_with_base(self.path)
8242 }
8243 }
8244 impl CoinMetadata {
8245 pub const ID_FIELD: &'static MessageField = &MessageField {
8246 name: "id",
8247 json_name: "id",
8248 number: 1i32,
8249 message_fields: None,
8250 };
8251 pub const DECIMALS_FIELD: &'static MessageField = &MessageField {
8252 name: "decimals",
8253 json_name: "decimals",
8254 number: 2i32,
8255 message_fields: None,
8256 };
8257 pub const NAME_FIELD: &'static MessageField = &MessageField {
8258 name: "name",
8259 json_name: "name",
8260 number: 3i32,
8261 message_fields: None,
8262 };
8263 pub const SYMBOL_FIELD: &'static MessageField = &MessageField {
8264 name: "symbol",
8265 json_name: "symbol",
8266 number: 4i32,
8267 message_fields: None,
8268 };
8269 pub const DESCRIPTION_FIELD: &'static MessageField = &MessageField {
8270 name: "description",
8271 json_name: "description",
8272 number: 5i32,
8273 message_fields: None,
8274 };
8275 pub const ICON_URL_FIELD: &'static MessageField = &MessageField {
8276 name: "icon_url",
8277 json_name: "iconUrl",
8278 number: 6i32,
8279 message_fields: None,
8280 };
8281 pub const METADATA_CAP_ID_FIELD: &'static MessageField = &MessageField {
8282 name: "metadata_cap_id",
8283 json_name: "metadataCapId",
8284 number: 7i32,
8285 message_fields: None,
8286 };
8287 pub const METADATA_CAP_STATE_FIELD: &'static MessageField = &MessageField {
8288 name: "metadata_cap_state",
8289 json_name: "metadataCapState",
8290 number: 8i32,
8291 message_fields: None,
8292 };
8293 }
8294 impl MessageFields for CoinMetadata {
8295 const FIELDS: &'static [&'static MessageField] = &[
8296 Self::ID_FIELD,
8297 Self::DECIMALS_FIELD,
8298 Self::NAME_FIELD,
8299 Self::SYMBOL_FIELD,
8300 Self::DESCRIPTION_FIELD,
8301 Self::ICON_URL_FIELD,
8302 Self::METADATA_CAP_ID_FIELD,
8303 Self::METADATA_CAP_STATE_FIELD,
8304 ];
8305 }
8306 impl CoinMetadata {
8307 pub fn path_builder() -> CoinMetadataFieldPathBuilder {
8308 CoinMetadataFieldPathBuilder::new()
8309 }
8310 }
8311 pub struct CoinMetadataFieldPathBuilder {
8312 path: Vec<&'static str>,
8313 }
8314 impl CoinMetadataFieldPathBuilder {
8315 #[allow(clippy::new_without_default)]
8316 pub fn new() -> Self {
8317 Self { path: Default::default() }
8318 }
8319 #[doc(hidden)]
8320 pub fn new_with_base(base: Vec<&'static str>) -> Self {
8321 Self { path: base }
8322 }
8323 pub fn finish(self) -> String {
8324 self.path.join(".")
8325 }
8326 pub fn id(mut self) -> String {
8327 self.path.push(CoinMetadata::ID_FIELD.name);
8328 self.finish()
8329 }
8330 pub fn decimals(mut self) -> String {
8331 self.path.push(CoinMetadata::DECIMALS_FIELD.name);
8332 self.finish()
8333 }
8334 pub fn name(mut self) -> String {
8335 self.path.push(CoinMetadata::NAME_FIELD.name);
8336 self.finish()
8337 }
8338 pub fn symbol(mut self) -> String {
8339 self.path.push(CoinMetadata::SYMBOL_FIELD.name);
8340 self.finish()
8341 }
8342 pub fn description(mut self) -> String {
8343 self.path.push(CoinMetadata::DESCRIPTION_FIELD.name);
8344 self.finish()
8345 }
8346 pub fn icon_url(mut self) -> String {
8347 self.path.push(CoinMetadata::ICON_URL_FIELD.name);
8348 self.finish()
8349 }
8350 pub fn metadata_cap_id(mut self) -> String {
8351 self.path.push(CoinMetadata::METADATA_CAP_ID_FIELD.name);
8352 self.finish()
8353 }
8354 pub fn metadata_cap_state(mut self) -> String {
8355 self.path.push(CoinMetadata::METADATA_CAP_STATE_FIELD.name);
8356 self.finish()
8357 }
8358 }
8359 impl CoinTreasury {
8360 pub const ID_FIELD: &'static MessageField = &MessageField {
8361 name: "id",
8362 json_name: "id",
8363 number: 1i32,
8364 message_fields: None,
8365 };
8366 pub const TOTAL_SUPPLY_FIELD: &'static MessageField = &MessageField {
8367 name: "total_supply",
8368 json_name: "totalSupply",
8369 number: 2i32,
8370 message_fields: None,
8371 };
8372 pub const SUPPLY_STATE_FIELD: &'static MessageField = &MessageField {
8373 name: "supply_state",
8374 json_name: "supplyState",
8375 number: 3i32,
8376 message_fields: None,
8377 };
8378 }
8379 impl MessageFields for CoinTreasury {
8380 const FIELDS: &'static [&'static MessageField] = &[
8381 Self::ID_FIELD,
8382 Self::TOTAL_SUPPLY_FIELD,
8383 Self::SUPPLY_STATE_FIELD,
8384 ];
8385 }
8386 impl CoinTreasury {
8387 pub fn path_builder() -> CoinTreasuryFieldPathBuilder {
8388 CoinTreasuryFieldPathBuilder::new()
8389 }
8390 }
8391 pub struct CoinTreasuryFieldPathBuilder {
8392 path: Vec<&'static str>,
8393 }
8394 impl CoinTreasuryFieldPathBuilder {
8395 #[allow(clippy::new_without_default)]
8396 pub fn new() -> Self {
8397 Self { path: Default::default() }
8398 }
8399 #[doc(hidden)]
8400 pub fn new_with_base(base: Vec<&'static str>) -> Self {
8401 Self { path: base }
8402 }
8403 pub fn finish(self) -> String {
8404 self.path.join(".")
8405 }
8406 pub fn id(mut self) -> String {
8407 self.path.push(CoinTreasury::ID_FIELD.name);
8408 self.finish()
8409 }
8410 pub fn total_supply(mut self) -> String {
8411 self.path.push(CoinTreasury::TOTAL_SUPPLY_FIELD.name);
8412 self.finish()
8413 }
8414 pub fn supply_state(mut self) -> String {
8415 self.path.push(CoinTreasury::SUPPLY_STATE_FIELD.name);
8416 self.finish()
8417 }
8418 }
8419 impl RegulatedCoinMetadata {
8420 pub const ID_FIELD: &'static MessageField = &MessageField {
8421 name: "id",
8422 json_name: "id",
8423 number: 1i32,
8424 message_fields: None,
8425 };
8426 pub const COIN_METADATA_OBJECT_FIELD: &'static MessageField = &MessageField {
8427 name: "coin_metadata_object",
8428 json_name: "coinMetadataObject",
8429 number: 2i32,
8430 message_fields: None,
8431 };
8432 pub const DENY_CAP_OBJECT_FIELD: &'static MessageField = &MessageField {
8433 name: "deny_cap_object",
8434 json_name: "denyCapObject",
8435 number: 3i32,
8436 message_fields: None,
8437 };
8438 pub const ALLOW_GLOBAL_PAUSE_FIELD: &'static MessageField = &MessageField {
8439 name: "allow_global_pause",
8440 json_name: "allowGlobalPause",
8441 number: 4i32,
8442 message_fields: None,
8443 };
8444 pub const VARIANT_FIELD: &'static MessageField = &MessageField {
8445 name: "variant",
8446 json_name: "variant",
8447 number: 5i32,
8448 message_fields: None,
8449 };
8450 pub const COIN_REGULATED_STATE_FIELD: &'static MessageField = &MessageField {
8451 name: "coin_regulated_state",
8452 json_name: "coinRegulatedState",
8453 number: 6i32,
8454 message_fields: None,
8455 };
8456 }
8457 impl MessageFields for RegulatedCoinMetadata {
8458 const FIELDS: &'static [&'static MessageField] = &[
8459 Self::ID_FIELD,
8460 Self::COIN_METADATA_OBJECT_FIELD,
8461 Self::DENY_CAP_OBJECT_FIELD,
8462 Self::ALLOW_GLOBAL_PAUSE_FIELD,
8463 Self::VARIANT_FIELD,
8464 Self::COIN_REGULATED_STATE_FIELD,
8465 ];
8466 }
8467 impl RegulatedCoinMetadata {
8468 pub fn path_builder() -> RegulatedCoinMetadataFieldPathBuilder {
8469 RegulatedCoinMetadataFieldPathBuilder::new()
8470 }
8471 }
8472 pub struct RegulatedCoinMetadataFieldPathBuilder {
8473 path: Vec<&'static str>,
8474 }
8475 impl RegulatedCoinMetadataFieldPathBuilder {
8476 #[allow(clippy::new_without_default)]
8477 pub fn new() -> Self {
8478 Self { path: Default::default() }
8479 }
8480 #[doc(hidden)]
8481 pub fn new_with_base(base: Vec<&'static str>) -> Self {
8482 Self { path: base }
8483 }
8484 pub fn finish(self) -> String {
8485 self.path.join(".")
8486 }
8487 pub fn id(mut self) -> String {
8488 self.path.push(RegulatedCoinMetadata::ID_FIELD.name);
8489 self.finish()
8490 }
8491 pub fn coin_metadata_object(mut self) -> String {
8492 self.path.push(RegulatedCoinMetadata::COIN_METADATA_OBJECT_FIELD.name);
8493 self.finish()
8494 }
8495 pub fn deny_cap_object(mut self) -> String {
8496 self.path.push(RegulatedCoinMetadata::DENY_CAP_OBJECT_FIELD.name);
8497 self.finish()
8498 }
8499 pub fn allow_global_pause(mut self) -> String {
8500 self.path.push(RegulatedCoinMetadata::ALLOW_GLOBAL_PAUSE_FIELD.name);
8501 self.finish()
8502 }
8503 pub fn variant(mut self) -> String {
8504 self.path.push(RegulatedCoinMetadata::VARIANT_FIELD.name);
8505 self.finish()
8506 }
8507 pub fn coin_regulated_state(mut self) -> String {
8508 self.path.push(RegulatedCoinMetadata::COIN_REGULATED_STATE_FIELD.name);
8509 self.finish()
8510 }
8511 }
8512 impl GetBalanceRequest {
8513 pub const OWNER_FIELD: &'static MessageField = &MessageField {
8514 name: "owner",
8515 json_name: "owner",
8516 number: 1i32,
8517 message_fields: None,
8518 };
8519 pub const COIN_TYPE_FIELD: &'static MessageField = &MessageField {
8520 name: "coin_type",
8521 json_name: "coinType",
8522 number: 2i32,
8523 message_fields: None,
8524 };
8525 }
8526 impl MessageFields for GetBalanceRequest {
8527 const FIELDS: &'static [&'static MessageField] = &[
8528 Self::OWNER_FIELD,
8529 Self::COIN_TYPE_FIELD,
8530 ];
8531 }
8532 impl GetBalanceRequest {
8533 pub fn path_builder() -> GetBalanceRequestFieldPathBuilder {
8534 GetBalanceRequestFieldPathBuilder::new()
8535 }
8536 }
8537 pub struct GetBalanceRequestFieldPathBuilder {
8538 path: Vec<&'static str>,
8539 }
8540 impl GetBalanceRequestFieldPathBuilder {
8541 #[allow(clippy::new_without_default)]
8542 pub fn new() -> Self {
8543 Self { path: Default::default() }
8544 }
8545 #[doc(hidden)]
8546 pub fn new_with_base(base: Vec<&'static str>) -> Self {
8547 Self { path: base }
8548 }
8549 pub fn finish(self) -> String {
8550 self.path.join(".")
8551 }
8552 pub fn owner(mut self) -> String {
8553 self.path.push(GetBalanceRequest::OWNER_FIELD.name);
8554 self.finish()
8555 }
8556 pub fn coin_type(mut self) -> String {
8557 self.path.push(GetBalanceRequest::COIN_TYPE_FIELD.name);
8558 self.finish()
8559 }
8560 }
8561 impl GetBalanceResponse {
8562 pub const BALANCE_FIELD: &'static MessageField = &MessageField {
8563 name: "balance",
8564 json_name: "balance",
8565 number: 1i32,
8566 message_fields: Some(Balance::FIELDS),
8567 };
8568 }
8569 impl MessageFields for GetBalanceResponse {
8570 const FIELDS: &'static [&'static MessageField] = &[Self::BALANCE_FIELD];
8571 }
8572 impl GetBalanceResponse {
8573 pub fn path_builder() -> GetBalanceResponseFieldPathBuilder {
8574 GetBalanceResponseFieldPathBuilder::new()
8575 }
8576 }
8577 pub struct GetBalanceResponseFieldPathBuilder {
8578 path: Vec<&'static str>,
8579 }
8580 impl GetBalanceResponseFieldPathBuilder {
8581 #[allow(clippy::new_without_default)]
8582 pub fn new() -> Self {
8583 Self { path: Default::default() }
8584 }
8585 #[doc(hidden)]
8586 pub fn new_with_base(base: Vec<&'static str>) -> Self {
8587 Self { path: base }
8588 }
8589 pub fn finish(self) -> String {
8590 self.path.join(".")
8591 }
8592 pub fn balance(mut self) -> BalanceFieldPathBuilder {
8593 self.path.push(GetBalanceResponse::BALANCE_FIELD.name);
8594 BalanceFieldPathBuilder::new_with_base(self.path)
8595 }
8596 }
8597 impl ListBalancesRequest {
8598 pub const OWNER_FIELD: &'static MessageField = &MessageField {
8599 name: "owner",
8600 json_name: "owner",
8601 number: 1i32,
8602 message_fields: None,
8603 };
8604 pub const PAGE_SIZE_FIELD: &'static MessageField = &MessageField {
8605 name: "page_size",
8606 json_name: "pageSize",
8607 number: 2i32,
8608 message_fields: None,
8609 };
8610 pub const PAGE_TOKEN_FIELD: &'static MessageField = &MessageField {
8611 name: "page_token",
8612 json_name: "pageToken",
8613 number: 3i32,
8614 message_fields: None,
8615 };
8616 }
8617 impl MessageFields for ListBalancesRequest {
8618 const FIELDS: &'static [&'static MessageField] = &[
8619 Self::OWNER_FIELD,
8620 Self::PAGE_SIZE_FIELD,
8621 Self::PAGE_TOKEN_FIELD,
8622 ];
8623 }
8624 impl ListBalancesRequest {
8625 pub fn path_builder() -> ListBalancesRequestFieldPathBuilder {
8626 ListBalancesRequestFieldPathBuilder::new()
8627 }
8628 }
8629 pub struct ListBalancesRequestFieldPathBuilder {
8630 path: Vec<&'static str>,
8631 }
8632 impl ListBalancesRequestFieldPathBuilder {
8633 #[allow(clippy::new_without_default)]
8634 pub fn new() -> Self {
8635 Self { path: Default::default() }
8636 }
8637 #[doc(hidden)]
8638 pub fn new_with_base(base: Vec<&'static str>) -> Self {
8639 Self { path: base }
8640 }
8641 pub fn finish(self) -> String {
8642 self.path.join(".")
8643 }
8644 pub fn owner(mut self) -> String {
8645 self.path.push(ListBalancesRequest::OWNER_FIELD.name);
8646 self.finish()
8647 }
8648 pub fn page_size(mut self) -> String {
8649 self.path.push(ListBalancesRequest::PAGE_SIZE_FIELD.name);
8650 self.finish()
8651 }
8652 pub fn page_token(mut self) -> String {
8653 self.path.push(ListBalancesRequest::PAGE_TOKEN_FIELD.name);
8654 self.finish()
8655 }
8656 }
8657 impl ListBalancesResponse {
8658 pub const BALANCES_FIELD: &'static MessageField = &MessageField {
8659 name: "balances",
8660 json_name: "balances",
8661 number: 1i32,
8662 message_fields: Some(Balance::FIELDS),
8663 };
8664 pub const NEXT_PAGE_TOKEN_FIELD: &'static MessageField = &MessageField {
8665 name: "next_page_token",
8666 json_name: "nextPageToken",
8667 number: 2i32,
8668 message_fields: None,
8669 };
8670 }
8671 impl MessageFields for ListBalancesResponse {
8672 const FIELDS: &'static [&'static MessageField] = &[
8673 Self::BALANCES_FIELD,
8674 Self::NEXT_PAGE_TOKEN_FIELD,
8675 ];
8676 }
8677 impl ListBalancesResponse {
8678 pub fn path_builder() -> ListBalancesResponseFieldPathBuilder {
8679 ListBalancesResponseFieldPathBuilder::new()
8680 }
8681 }
8682 pub struct ListBalancesResponseFieldPathBuilder {
8683 path: Vec<&'static str>,
8684 }
8685 impl ListBalancesResponseFieldPathBuilder {
8686 #[allow(clippy::new_without_default)]
8687 pub fn new() -> Self {
8688 Self { path: Default::default() }
8689 }
8690 #[doc(hidden)]
8691 pub fn new_with_base(base: Vec<&'static str>) -> Self {
8692 Self { path: base }
8693 }
8694 pub fn finish(self) -> String {
8695 self.path.join(".")
8696 }
8697 pub fn balances(mut self) -> BalanceFieldPathBuilder {
8698 self.path.push(ListBalancesResponse::BALANCES_FIELD.name);
8699 BalanceFieldPathBuilder::new_with_base(self.path)
8700 }
8701 pub fn next_page_token(mut self) -> String {
8702 self.path.push(ListBalancesResponse::NEXT_PAGE_TOKEN_FIELD.name);
8703 self.finish()
8704 }
8705 }
8706 impl Balance {
8707 pub const COIN_TYPE_FIELD: &'static MessageField = &MessageField {
8708 name: "coin_type",
8709 json_name: "coinType",
8710 number: 1i32,
8711 message_fields: None,
8712 };
8713 pub const BALANCE_FIELD: &'static MessageField = &MessageField {
8714 name: "balance",
8715 json_name: "balance",
8716 number: 3i32,
8717 message_fields: None,
8718 };
8719 pub const ADDRESS_BALANCE_FIELD: &'static MessageField = &MessageField {
8720 name: "address_balance",
8721 json_name: "addressBalance",
8722 number: 4i32,
8723 message_fields: None,
8724 };
8725 pub const COIN_BALANCE_FIELD: &'static MessageField = &MessageField {
8726 name: "coin_balance",
8727 json_name: "coinBalance",
8728 number: 5i32,
8729 message_fields: None,
8730 };
8731 }
8732 impl MessageFields for Balance {
8733 const FIELDS: &'static [&'static MessageField] = &[
8734 Self::COIN_TYPE_FIELD,
8735 Self::BALANCE_FIELD,
8736 Self::ADDRESS_BALANCE_FIELD,
8737 Self::COIN_BALANCE_FIELD,
8738 ];
8739 }
8740 impl Balance {
8741 pub fn path_builder() -> BalanceFieldPathBuilder {
8742 BalanceFieldPathBuilder::new()
8743 }
8744 }
8745 pub struct BalanceFieldPathBuilder {
8746 path: Vec<&'static str>,
8747 }
8748 impl BalanceFieldPathBuilder {
8749 #[allow(clippy::new_without_default)]
8750 pub fn new() -> Self {
8751 Self { path: Default::default() }
8752 }
8753 #[doc(hidden)]
8754 pub fn new_with_base(base: Vec<&'static str>) -> Self {
8755 Self { path: base }
8756 }
8757 pub fn finish(self) -> String {
8758 self.path.join(".")
8759 }
8760 pub fn coin_type(mut self) -> String {
8761 self.path.push(Balance::COIN_TYPE_FIELD.name);
8762 self.finish()
8763 }
8764 pub fn balance(mut self) -> String {
8765 self.path.push(Balance::BALANCE_FIELD.name);
8766 self.finish()
8767 }
8768 pub fn address_balance(mut self) -> String {
8769 self.path.push(Balance::ADDRESS_BALANCE_FIELD.name);
8770 self.finish()
8771 }
8772 pub fn coin_balance(mut self) -> String {
8773 self.path.push(Balance::COIN_BALANCE_FIELD.name);
8774 self.finish()
8775 }
8776 }
8777 impl ListDynamicFieldsRequest {
8778 pub const PARENT_FIELD: &'static MessageField = &MessageField {
8779 name: "parent",
8780 json_name: "parent",
8781 number: 1i32,
8782 message_fields: None,
8783 };
8784 pub const PAGE_SIZE_FIELD: &'static MessageField = &MessageField {
8785 name: "page_size",
8786 json_name: "pageSize",
8787 number: 2i32,
8788 message_fields: None,
8789 };
8790 pub const PAGE_TOKEN_FIELD: &'static MessageField = &MessageField {
8791 name: "page_token",
8792 json_name: "pageToken",
8793 number: 3i32,
8794 message_fields: None,
8795 };
8796 pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
8797 name: "read_mask",
8798 json_name: "readMask",
8799 number: 4i32,
8800 message_fields: None,
8801 };
8802 }
8803 impl MessageFields for ListDynamicFieldsRequest {
8804 const FIELDS: &'static [&'static MessageField] = &[
8805 Self::PARENT_FIELD,
8806 Self::PAGE_SIZE_FIELD,
8807 Self::PAGE_TOKEN_FIELD,
8808 Self::READ_MASK_FIELD,
8809 ];
8810 }
8811 impl ListDynamicFieldsRequest {
8812 pub fn path_builder() -> ListDynamicFieldsRequestFieldPathBuilder {
8813 ListDynamicFieldsRequestFieldPathBuilder::new()
8814 }
8815 }
8816 pub struct ListDynamicFieldsRequestFieldPathBuilder {
8817 path: Vec<&'static str>,
8818 }
8819 impl ListDynamicFieldsRequestFieldPathBuilder {
8820 #[allow(clippy::new_without_default)]
8821 pub fn new() -> Self {
8822 Self { path: Default::default() }
8823 }
8824 #[doc(hidden)]
8825 pub fn new_with_base(base: Vec<&'static str>) -> Self {
8826 Self { path: base }
8827 }
8828 pub fn finish(self) -> String {
8829 self.path.join(".")
8830 }
8831 pub fn parent(mut self) -> String {
8832 self.path.push(ListDynamicFieldsRequest::PARENT_FIELD.name);
8833 self.finish()
8834 }
8835 pub fn page_size(mut self) -> String {
8836 self.path.push(ListDynamicFieldsRequest::PAGE_SIZE_FIELD.name);
8837 self.finish()
8838 }
8839 pub fn page_token(mut self) -> String {
8840 self.path.push(ListDynamicFieldsRequest::PAGE_TOKEN_FIELD.name);
8841 self.finish()
8842 }
8843 pub fn read_mask(mut self) -> String {
8844 self.path.push(ListDynamicFieldsRequest::READ_MASK_FIELD.name);
8845 self.finish()
8846 }
8847 }
8848 impl ListDynamicFieldsResponse {
8849 pub const DYNAMIC_FIELDS_FIELD: &'static MessageField = &MessageField {
8850 name: "dynamic_fields",
8851 json_name: "dynamicFields",
8852 number: 1i32,
8853 message_fields: Some(DynamicField::FIELDS),
8854 };
8855 pub const NEXT_PAGE_TOKEN_FIELD: &'static MessageField = &MessageField {
8856 name: "next_page_token",
8857 json_name: "nextPageToken",
8858 number: 2i32,
8859 message_fields: None,
8860 };
8861 }
8862 impl MessageFields for ListDynamicFieldsResponse {
8863 const FIELDS: &'static [&'static MessageField] = &[
8864 Self::DYNAMIC_FIELDS_FIELD,
8865 Self::NEXT_PAGE_TOKEN_FIELD,
8866 ];
8867 }
8868 impl ListDynamicFieldsResponse {
8869 pub fn path_builder() -> ListDynamicFieldsResponseFieldPathBuilder {
8870 ListDynamicFieldsResponseFieldPathBuilder::new()
8871 }
8872 }
8873 pub struct ListDynamicFieldsResponseFieldPathBuilder {
8874 path: Vec<&'static str>,
8875 }
8876 impl ListDynamicFieldsResponseFieldPathBuilder {
8877 #[allow(clippy::new_without_default)]
8878 pub fn new() -> Self {
8879 Self { path: Default::default() }
8880 }
8881 #[doc(hidden)]
8882 pub fn new_with_base(base: Vec<&'static str>) -> Self {
8883 Self { path: base }
8884 }
8885 pub fn finish(self) -> String {
8886 self.path.join(".")
8887 }
8888 pub fn dynamic_fields(mut self) -> DynamicFieldFieldPathBuilder {
8889 self.path.push(ListDynamicFieldsResponse::DYNAMIC_FIELDS_FIELD.name);
8890 DynamicFieldFieldPathBuilder::new_with_base(self.path)
8891 }
8892 pub fn next_page_token(mut self) -> String {
8893 self.path.push(ListDynamicFieldsResponse::NEXT_PAGE_TOKEN_FIELD.name);
8894 self.finish()
8895 }
8896 }
8897 impl DynamicField {
8898 pub const KIND_FIELD: &'static MessageField = &MessageField {
8899 name: "kind",
8900 json_name: "kind",
8901 number: 1i32,
8902 message_fields: None,
8903 };
8904 pub const PARENT_FIELD: &'static MessageField = &MessageField {
8905 name: "parent",
8906 json_name: "parent",
8907 number: 2i32,
8908 message_fields: None,
8909 };
8910 pub const FIELD_ID_FIELD: &'static MessageField = &MessageField {
8911 name: "field_id",
8912 json_name: "fieldId",
8913 number: 3i32,
8914 message_fields: None,
8915 };
8916 pub const FIELD_OBJECT_FIELD: &'static MessageField = &MessageField {
8917 name: "field_object",
8918 json_name: "fieldObject",
8919 number: 4i32,
8920 message_fields: Some(Object::FIELDS),
8921 };
8922 pub const NAME_FIELD: &'static MessageField = &MessageField {
8923 name: "name",
8924 json_name: "name",
8925 number: 5i32,
8926 message_fields: Some(Bcs::FIELDS),
8927 };
8928 pub const VALUE_FIELD: &'static MessageField = &MessageField {
8929 name: "value",
8930 json_name: "value",
8931 number: 6i32,
8932 message_fields: Some(Bcs::FIELDS),
8933 };
8934 pub const VALUE_TYPE_FIELD: &'static MessageField = &MessageField {
8935 name: "value_type",
8936 json_name: "valueType",
8937 number: 7i32,
8938 message_fields: None,
8939 };
8940 pub const CHILD_ID_FIELD: &'static MessageField = &MessageField {
8941 name: "child_id",
8942 json_name: "childId",
8943 number: 8i32,
8944 message_fields: None,
8945 };
8946 pub const CHILD_OBJECT_FIELD: &'static MessageField = &MessageField {
8947 name: "child_object",
8948 json_name: "childObject",
8949 number: 9i32,
8950 message_fields: Some(Object::FIELDS),
8951 };
8952 }
8953 impl MessageFields for DynamicField {
8954 const FIELDS: &'static [&'static MessageField] = &[
8955 Self::KIND_FIELD,
8956 Self::PARENT_FIELD,
8957 Self::FIELD_ID_FIELD,
8958 Self::FIELD_OBJECT_FIELD,
8959 Self::NAME_FIELD,
8960 Self::VALUE_FIELD,
8961 Self::VALUE_TYPE_FIELD,
8962 Self::CHILD_ID_FIELD,
8963 Self::CHILD_OBJECT_FIELD,
8964 ];
8965 }
8966 impl DynamicField {
8967 pub fn path_builder() -> DynamicFieldFieldPathBuilder {
8968 DynamicFieldFieldPathBuilder::new()
8969 }
8970 }
8971 pub struct DynamicFieldFieldPathBuilder {
8972 path: Vec<&'static str>,
8973 }
8974 impl DynamicFieldFieldPathBuilder {
8975 #[allow(clippy::new_without_default)]
8976 pub fn new() -> Self {
8977 Self { path: Default::default() }
8978 }
8979 #[doc(hidden)]
8980 pub fn new_with_base(base: Vec<&'static str>) -> Self {
8981 Self { path: base }
8982 }
8983 pub fn finish(self) -> String {
8984 self.path.join(".")
8985 }
8986 pub fn kind(mut self) -> String {
8987 self.path.push(DynamicField::KIND_FIELD.name);
8988 self.finish()
8989 }
8990 pub fn parent(mut self) -> String {
8991 self.path.push(DynamicField::PARENT_FIELD.name);
8992 self.finish()
8993 }
8994 pub fn field_id(mut self) -> String {
8995 self.path.push(DynamicField::FIELD_ID_FIELD.name);
8996 self.finish()
8997 }
8998 pub fn field_object(mut self) -> ObjectFieldPathBuilder {
8999 self.path.push(DynamicField::FIELD_OBJECT_FIELD.name);
9000 ObjectFieldPathBuilder::new_with_base(self.path)
9001 }
9002 pub fn name(mut self) -> BcsFieldPathBuilder {
9003 self.path.push(DynamicField::NAME_FIELD.name);
9004 BcsFieldPathBuilder::new_with_base(self.path)
9005 }
9006 pub fn value(mut self) -> BcsFieldPathBuilder {
9007 self.path.push(DynamicField::VALUE_FIELD.name);
9008 BcsFieldPathBuilder::new_with_base(self.path)
9009 }
9010 pub fn value_type(mut self) -> String {
9011 self.path.push(DynamicField::VALUE_TYPE_FIELD.name);
9012 self.finish()
9013 }
9014 pub fn child_id(mut self) -> String {
9015 self.path.push(DynamicField::CHILD_ID_FIELD.name);
9016 self.finish()
9017 }
9018 pub fn child_object(mut self) -> ObjectFieldPathBuilder {
9019 self.path.push(DynamicField::CHILD_OBJECT_FIELD.name);
9020 ObjectFieldPathBuilder::new_with_base(self.path)
9021 }
9022 }
9023 impl ListOwnedObjectsRequest {
9024 pub const OWNER_FIELD: &'static MessageField = &MessageField {
9025 name: "owner",
9026 json_name: "owner",
9027 number: 1i32,
9028 message_fields: None,
9029 };
9030 pub const PAGE_SIZE_FIELD: &'static MessageField = &MessageField {
9031 name: "page_size",
9032 json_name: "pageSize",
9033 number: 2i32,
9034 message_fields: None,
9035 };
9036 pub const PAGE_TOKEN_FIELD: &'static MessageField = &MessageField {
9037 name: "page_token",
9038 json_name: "pageToken",
9039 number: 3i32,
9040 message_fields: None,
9041 };
9042 pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
9043 name: "read_mask",
9044 json_name: "readMask",
9045 number: 4i32,
9046 message_fields: None,
9047 };
9048 pub const OBJECT_TYPE_FIELD: &'static MessageField = &MessageField {
9049 name: "object_type",
9050 json_name: "objectType",
9051 number: 5i32,
9052 message_fields: None,
9053 };
9054 }
9055 impl MessageFields for ListOwnedObjectsRequest {
9056 const FIELDS: &'static [&'static MessageField] = &[
9057 Self::OWNER_FIELD,
9058 Self::PAGE_SIZE_FIELD,
9059 Self::PAGE_TOKEN_FIELD,
9060 Self::READ_MASK_FIELD,
9061 Self::OBJECT_TYPE_FIELD,
9062 ];
9063 }
9064 impl ListOwnedObjectsRequest {
9065 pub fn path_builder() -> ListOwnedObjectsRequestFieldPathBuilder {
9066 ListOwnedObjectsRequestFieldPathBuilder::new()
9067 }
9068 }
9069 pub struct ListOwnedObjectsRequestFieldPathBuilder {
9070 path: Vec<&'static str>,
9071 }
9072 impl ListOwnedObjectsRequestFieldPathBuilder {
9073 #[allow(clippy::new_without_default)]
9074 pub fn new() -> Self {
9075 Self { path: Default::default() }
9076 }
9077 #[doc(hidden)]
9078 pub fn new_with_base(base: Vec<&'static str>) -> Self {
9079 Self { path: base }
9080 }
9081 pub fn finish(self) -> String {
9082 self.path.join(".")
9083 }
9084 pub fn owner(mut self) -> String {
9085 self.path.push(ListOwnedObjectsRequest::OWNER_FIELD.name);
9086 self.finish()
9087 }
9088 pub fn page_size(mut self) -> String {
9089 self.path.push(ListOwnedObjectsRequest::PAGE_SIZE_FIELD.name);
9090 self.finish()
9091 }
9092 pub fn page_token(mut self) -> String {
9093 self.path.push(ListOwnedObjectsRequest::PAGE_TOKEN_FIELD.name);
9094 self.finish()
9095 }
9096 pub fn read_mask(mut self) -> String {
9097 self.path.push(ListOwnedObjectsRequest::READ_MASK_FIELD.name);
9098 self.finish()
9099 }
9100 pub fn object_type(mut self) -> String {
9101 self.path.push(ListOwnedObjectsRequest::OBJECT_TYPE_FIELD.name);
9102 self.finish()
9103 }
9104 }
9105 impl ListOwnedObjectsResponse {
9106 pub const OBJECTS_FIELD: &'static MessageField = &MessageField {
9107 name: "objects",
9108 json_name: "objects",
9109 number: 1i32,
9110 message_fields: Some(Object::FIELDS),
9111 };
9112 pub const NEXT_PAGE_TOKEN_FIELD: &'static MessageField = &MessageField {
9113 name: "next_page_token",
9114 json_name: "nextPageToken",
9115 number: 2i32,
9116 message_fields: None,
9117 };
9118 }
9119 impl MessageFields for ListOwnedObjectsResponse {
9120 const FIELDS: &'static [&'static MessageField] = &[
9121 Self::OBJECTS_FIELD,
9122 Self::NEXT_PAGE_TOKEN_FIELD,
9123 ];
9124 }
9125 impl ListOwnedObjectsResponse {
9126 pub fn path_builder() -> ListOwnedObjectsResponseFieldPathBuilder {
9127 ListOwnedObjectsResponseFieldPathBuilder::new()
9128 }
9129 }
9130 pub struct ListOwnedObjectsResponseFieldPathBuilder {
9131 path: Vec<&'static str>,
9132 }
9133 impl ListOwnedObjectsResponseFieldPathBuilder {
9134 #[allow(clippy::new_without_default)]
9135 pub fn new() -> Self {
9136 Self { path: Default::default() }
9137 }
9138 #[doc(hidden)]
9139 pub fn new_with_base(base: Vec<&'static str>) -> Self {
9140 Self { path: base }
9141 }
9142 pub fn finish(self) -> String {
9143 self.path.join(".")
9144 }
9145 pub fn objects(mut self) -> ObjectFieldPathBuilder {
9146 self.path.push(ListOwnedObjectsResponse::OBJECTS_FIELD.name);
9147 ObjectFieldPathBuilder::new_with_base(self.path)
9148 }
9149 pub fn next_page_token(mut self) -> String {
9150 self.path.push(ListOwnedObjectsResponse::NEXT_PAGE_TOKEN_FIELD.name);
9151 self.finish()
9152 }
9153 }
9154 impl SubscribeCheckpointsRequest {
9155 pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
9156 name: "read_mask",
9157 json_name: "readMask",
9158 number: 1i32,
9159 message_fields: None,
9160 };
9161 pub const FILTER_FIELD: &'static MessageField = &MessageField {
9162 name: "filter",
9163 json_name: "filter",
9164 number: 2i32,
9165 message_fields: Some(TransactionFilter::FIELDS),
9166 };
9167 }
9168 impl MessageFields for SubscribeCheckpointsRequest {
9169 const FIELDS: &'static [&'static MessageField] = &[
9170 Self::READ_MASK_FIELD,
9171 Self::FILTER_FIELD,
9172 ];
9173 }
9174 impl SubscribeCheckpointsRequest {
9175 pub fn path_builder() -> SubscribeCheckpointsRequestFieldPathBuilder {
9176 SubscribeCheckpointsRequestFieldPathBuilder::new()
9177 }
9178 }
9179 pub struct SubscribeCheckpointsRequestFieldPathBuilder {
9180 path: Vec<&'static str>,
9181 }
9182 impl SubscribeCheckpointsRequestFieldPathBuilder {
9183 #[allow(clippy::new_without_default)]
9184 pub fn new() -> Self {
9185 Self { path: Default::default() }
9186 }
9187 #[doc(hidden)]
9188 pub fn new_with_base(base: Vec<&'static str>) -> Self {
9189 Self { path: base }
9190 }
9191 pub fn finish(self) -> String {
9192 self.path.join(".")
9193 }
9194 pub fn read_mask(mut self) -> String {
9195 self.path.push(SubscribeCheckpointsRequest::READ_MASK_FIELD.name);
9196 self.finish()
9197 }
9198 pub fn filter(mut self) -> TransactionFilterFieldPathBuilder {
9199 self.path.push(SubscribeCheckpointsRequest::FILTER_FIELD.name);
9200 TransactionFilterFieldPathBuilder::new_with_base(self.path)
9201 }
9202 }
9203 impl SubscribeCheckpointsResponse {
9204 pub const CURSOR_FIELD: &'static MessageField = &MessageField {
9205 name: "cursor",
9206 json_name: "cursor",
9207 number: 1i32,
9208 message_fields: None,
9209 };
9210 pub const CHECKPOINT_FIELD: &'static MessageField = &MessageField {
9211 name: "checkpoint",
9212 json_name: "checkpoint",
9213 number: 2i32,
9214 message_fields: Some(Checkpoint::FIELDS),
9215 };
9216 }
9217 impl MessageFields for SubscribeCheckpointsResponse {
9218 const FIELDS: &'static [&'static MessageField] = &[
9219 Self::CURSOR_FIELD,
9220 Self::CHECKPOINT_FIELD,
9221 ];
9222 }
9223 impl SubscribeCheckpointsResponse {
9224 pub fn path_builder() -> SubscribeCheckpointsResponseFieldPathBuilder {
9225 SubscribeCheckpointsResponseFieldPathBuilder::new()
9226 }
9227 }
9228 pub struct SubscribeCheckpointsResponseFieldPathBuilder {
9229 path: Vec<&'static str>,
9230 }
9231 impl SubscribeCheckpointsResponseFieldPathBuilder {
9232 #[allow(clippy::new_without_default)]
9233 pub fn new() -> Self {
9234 Self { path: Default::default() }
9235 }
9236 #[doc(hidden)]
9237 pub fn new_with_base(base: Vec<&'static str>) -> Self {
9238 Self { path: base }
9239 }
9240 pub fn finish(self) -> String {
9241 self.path.join(".")
9242 }
9243 pub fn cursor(mut self) -> String {
9244 self.path.push(SubscribeCheckpointsResponse::CURSOR_FIELD.name);
9245 self.finish()
9246 }
9247 pub fn checkpoint(mut self) -> CheckpointFieldPathBuilder {
9248 self.path.push(SubscribeCheckpointsResponse::CHECKPOINT_FIELD.name);
9249 CheckpointFieldPathBuilder::new_with_base(self.path)
9250 }
9251 }
9252 impl SubscribeTransactionsRequest {
9253 pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
9254 name: "read_mask",
9255 json_name: "readMask",
9256 number: 1i32,
9257 message_fields: None,
9258 };
9259 pub const FILTER_FIELD: &'static MessageField = &MessageField {
9260 name: "filter",
9261 json_name: "filter",
9262 number: 2i32,
9263 message_fields: Some(TransactionFilter::FIELDS),
9264 };
9265 }
9266 impl MessageFields for SubscribeTransactionsRequest {
9267 const FIELDS: &'static [&'static MessageField] = &[
9268 Self::READ_MASK_FIELD,
9269 Self::FILTER_FIELD,
9270 ];
9271 }
9272 impl SubscribeTransactionsRequest {
9273 pub fn path_builder() -> SubscribeTransactionsRequestFieldPathBuilder {
9274 SubscribeTransactionsRequestFieldPathBuilder::new()
9275 }
9276 }
9277 pub struct SubscribeTransactionsRequestFieldPathBuilder {
9278 path: Vec<&'static str>,
9279 }
9280 impl SubscribeTransactionsRequestFieldPathBuilder {
9281 #[allow(clippy::new_without_default)]
9282 pub fn new() -> Self {
9283 Self { path: Default::default() }
9284 }
9285 #[doc(hidden)]
9286 pub fn new_with_base(base: Vec<&'static str>) -> Self {
9287 Self { path: base }
9288 }
9289 pub fn finish(self) -> String {
9290 self.path.join(".")
9291 }
9292 pub fn read_mask(mut self) -> String {
9293 self.path.push(SubscribeTransactionsRequest::READ_MASK_FIELD.name);
9294 self.finish()
9295 }
9296 pub fn filter(mut self) -> TransactionFilterFieldPathBuilder {
9297 self.path.push(SubscribeTransactionsRequest::FILTER_FIELD.name);
9298 TransactionFilterFieldPathBuilder::new_with_base(self.path)
9299 }
9300 }
9301 impl SubscribeTransactionsResponse {
9302 pub const TRANSACTION_FIELD: &'static MessageField = &MessageField {
9303 name: "transaction",
9304 json_name: "transaction",
9305 number: 1i32,
9306 message_fields: Some(ExecutedTransaction::FIELDS),
9307 };
9308 pub const WATERMARK_FIELD: &'static MessageField = &MessageField {
9309 name: "watermark",
9310 json_name: "watermark",
9311 number: 2i32,
9312 message_fields: Some(Watermark::FIELDS),
9313 };
9314 }
9315 impl MessageFields for SubscribeTransactionsResponse {
9316 const FIELDS: &'static [&'static MessageField] = &[
9317 Self::TRANSACTION_FIELD,
9318 Self::WATERMARK_FIELD,
9319 ];
9320 }
9321 impl SubscribeTransactionsResponse {
9322 pub fn path_builder() -> SubscribeTransactionsResponseFieldPathBuilder {
9323 SubscribeTransactionsResponseFieldPathBuilder::new()
9324 }
9325 }
9326 pub struct SubscribeTransactionsResponseFieldPathBuilder {
9327 path: Vec<&'static str>,
9328 }
9329 impl SubscribeTransactionsResponseFieldPathBuilder {
9330 #[allow(clippy::new_without_default)]
9331 pub fn new() -> Self {
9332 Self { path: Default::default() }
9333 }
9334 #[doc(hidden)]
9335 pub fn new_with_base(base: Vec<&'static str>) -> Self {
9336 Self { path: base }
9337 }
9338 pub fn finish(self) -> String {
9339 self.path.join(".")
9340 }
9341 pub fn transaction(mut self) -> ExecutedTransactionFieldPathBuilder {
9342 self.path.push(SubscribeTransactionsResponse::TRANSACTION_FIELD.name);
9343 ExecutedTransactionFieldPathBuilder::new_with_base(self.path)
9344 }
9345 pub fn watermark(mut self) -> WatermarkFieldPathBuilder {
9346 self.path.push(SubscribeTransactionsResponse::WATERMARK_FIELD.name);
9347 WatermarkFieldPathBuilder::new_with_base(self.path)
9348 }
9349 }
9350 impl SubscribeEventsRequest {
9351 pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
9352 name: "read_mask",
9353 json_name: "readMask",
9354 number: 1i32,
9355 message_fields: None,
9356 };
9357 pub const FILTER_FIELD: &'static MessageField = &MessageField {
9358 name: "filter",
9359 json_name: "filter",
9360 number: 2i32,
9361 message_fields: Some(EventFilter::FIELDS),
9362 };
9363 }
9364 impl MessageFields for SubscribeEventsRequest {
9365 const FIELDS: &'static [&'static MessageField] = &[
9366 Self::READ_MASK_FIELD,
9367 Self::FILTER_FIELD,
9368 ];
9369 }
9370 impl SubscribeEventsRequest {
9371 pub fn path_builder() -> SubscribeEventsRequestFieldPathBuilder {
9372 SubscribeEventsRequestFieldPathBuilder::new()
9373 }
9374 }
9375 pub struct SubscribeEventsRequestFieldPathBuilder {
9376 path: Vec<&'static str>,
9377 }
9378 impl SubscribeEventsRequestFieldPathBuilder {
9379 #[allow(clippy::new_without_default)]
9380 pub fn new() -> Self {
9381 Self { path: Default::default() }
9382 }
9383 #[doc(hidden)]
9384 pub fn new_with_base(base: Vec<&'static str>) -> Self {
9385 Self { path: base }
9386 }
9387 pub fn finish(self) -> String {
9388 self.path.join(".")
9389 }
9390 pub fn read_mask(mut self) -> String {
9391 self.path.push(SubscribeEventsRequest::READ_MASK_FIELD.name);
9392 self.finish()
9393 }
9394 pub fn filter(mut self) -> EventFilterFieldPathBuilder {
9395 self.path.push(SubscribeEventsRequest::FILTER_FIELD.name);
9396 EventFilterFieldPathBuilder::new_with_base(self.path)
9397 }
9398 }
9399 impl SubscribeEventsResponse {
9400 pub const EVENT_FIELD: &'static MessageField = &MessageField {
9401 name: "event",
9402 json_name: "event",
9403 number: 1i32,
9404 message_fields: Some(Event::FIELDS),
9405 };
9406 pub const WATERMARK_FIELD: &'static MessageField = &MessageField {
9407 name: "watermark",
9408 json_name: "watermark",
9409 number: 2i32,
9410 message_fields: Some(Watermark::FIELDS),
9411 };
9412 }
9413 impl MessageFields for SubscribeEventsResponse {
9414 const FIELDS: &'static [&'static MessageField] = &[
9415 Self::EVENT_FIELD,
9416 Self::WATERMARK_FIELD,
9417 ];
9418 }
9419 impl SubscribeEventsResponse {
9420 pub fn path_builder() -> SubscribeEventsResponseFieldPathBuilder {
9421 SubscribeEventsResponseFieldPathBuilder::new()
9422 }
9423 }
9424 pub struct SubscribeEventsResponseFieldPathBuilder {
9425 path: Vec<&'static str>,
9426 }
9427 impl SubscribeEventsResponseFieldPathBuilder {
9428 #[allow(clippy::new_without_default)]
9429 pub fn new() -> Self {
9430 Self { path: Default::default() }
9431 }
9432 #[doc(hidden)]
9433 pub fn new_with_base(base: Vec<&'static str>) -> Self {
9434 Self { path: base }
9435 }
9436 pub fn finish(self) -> String {
9437 self.path.join(".")
9438 }
9439 pub fn event(mut self) -> EventFieldPathBuilder {
9440 self.path.push(SubscribeEventsResponse::EVENT_FIELD.name);
9441 EventFieldPathBuilder::new_with_base(self.path)
9442 }
9443 pub fn watermark(mut self) -> WatermarkFieldPathBuilder {
9444 self.path.push(SubscribeEventsResponse::WATERMARK_FIELD.name);
9445 WatermarkFieldPathBuilder::new_with_base(self.path)
9446 }
9447 }
9448 impl SystemState {
9449 pub const VERSION_FIELD: &'static MessageField = &MessageField {
9450 name: "version",
9451 json_name: "version",
9452 number: 1i32,
9453 message_fields: None,
9454 };
9455 pub const EPOCH_FIELD: &'static MessageField = &MessageField {
9456 name: "epoch",
9457 json_name: "epoch",
9458 number: 2i32,
9459 message_fields: None,
9460 };
9461 pub const PROTOCOL_VERSION_FIELD: &'static MessageField = &MessageField {
9462 name: "protocol_version",
9463 json_name: "protocolVersion",
9464 number: 3i32,
9465 message_fields: None,
9466 };
9467 pub const VALIDATORS_FIELD: &'static MessageField = &MessageField {
9468 name: "validators",
9469 json_name: "validators",
9470 number: 4i32,
9471 message_fields: Some(ValidatorSet::FIELDS),
9472 };
9473 pub const STORAGE_FUND_FIELD: &'static MessageField = &MessageField {
9474 name: "storage_fund",
9475 json_name: "storageFund",
9476 number: 5i32,
9477 message_fields: Some(StorageFund::FIELDS),
9478 };
9479 pub const PARAMETERS_FIELD: &'static MessageField = &MessageField {
9480 name: "parameters",
9481 json_name: "parameters",
9482 number: 6i32,
9483 message_fields: Some(SystemParameters::FIELDS),
9484 };
9485 pub const REFERENCE_GAS_PRICE_FIELD: &'static MessageField = &MessageField {
9486 name: "reference_gas_price",
9487 json_name: "referenceGasPrice",
9488 number: 7i32,
9489 message_fields: None,
9490 };
9491 pub const VALIDATOR_REPORT_RECORDS_FIELD: &'static MessageField = &MessageField {
9492 name: "validator_report_records",
9493 json_name: "validatorReportRecords",
9494 number: 8i32,
9495 message_fields: Some(ValidatorReportRecord::FIELDS),
9496 };
9497 pub const STAKE_SUBSIDY_FIELD: &'static MessageField = &MessageField {
9498 name: "stake_subsidy",
9499 json_name: "stakeSubsidy",
9500 number: 9i32,
9501 message_fields: Some(StakeSubsidy::FIELDS),
9502 };
9503 pub const SAFE_MODE_FIELD: &'static MessageField = &MessageField {
9504 name: "safe_mode",
9505 json_name: "safeMode",
9506 number: 10i32,
9507 message_fields: None,
9508 };
9509 pub const SAFE_MODE_STORAGE_REWARDS_FIELD: &'static MessageField = &MessageField {
9510 name: "safe_mode_storage_rewards",
9511 json_name: "safeModeStorageRewards",
9512 number: 11i32,
9513 message_fields: None,
9514 };
9515 pub const SAFE_MODE_COMPUTATION_REWARDS_FIELD: &'static MessageField = &MessageField {
9516 name: "safe_mode_computation_rewards",
9517 json_name: "safeModeComputationRewards",
9518 number: 12i32,
9519 message_fields: None,
9520 };
9521 pub const SAFE_MODE_STORAGE_REBATES_FIELD: &'static MessageField = &MessageField {
9522 name: "safe_mode_storage_rebates",
9523 json_name: "safeModeStorageRebates",
9524 number: 13i32,
9525 message_fields: None,
9526 };
9527 pub const SAFE_MODE_NON_REFUNDABLE_STORAGE_FEE_FIELD: &'static MessageField = &MessageField {
9528 name: "safe_mode_non_refundable_storage_fee",
9529 json_name: "safeModeNonRefundableStorageFee",
9530 number: 14i32,
9531 message_fields: None,
9532 };
9533 pub const EPOCH_START_TIMESTAMP_MS_FIELD: &'static MessageField = &MessageField {
9534 name: "epoch_start_timestamp_ms",
9535 json_name: "epochStartTimestampMs",
9536 number: 15i32,
9537 message_fields: None,
9538 };
9539 pub const EXTRA_FIELDS_FIELD: &'static MessageField = &MessageField {
9540 name: "extra_fields",
9541 json_name: "extraFields",
9542 number: 16i32,
9543 message_fields: Some(MoveTable::FIELDS),
9544 };
9545 }
9546 impl MessageFields for SystemState {
9547 const FIELDS: &'static [&'static MessageField] = &[
9548 Self::VERSION_FIELD,
9549 Self::EPOCH_FIELD,
9550 Self::PROTOCOL_VERSION_FIELD,
9551 Self::VALIDATORS_FIELD,
9552 Self::STORAGE_FUND_FIELD,
9553 Self::PARAMETERS_FIELD,
9554 Self::REFERENCE_GAS_PRICE_FIELD,
9555 Self::VALIDATOR_REPORT_RECORDS_FIELD,
9556 Self::STAKE_SUBSIDY_FIELD,
9557 Self::SAFE_MODE_FIELD,
9558 Self::SAFE_MODE_STORAGE_REWARDS_FIELD,
9559 Self::SAFE_MODE_COMPUTATION_REWARDS_FIELD,
9560 Self::SAFE_MODE_STORAGE_REBATES_FIELD,
9561 Self::SAFE_MODE_NON_REFUNDABLE_STORAGE_FEE_FIELD,
9562 Self::EPOCH_START_TIMESTAMP_MS_FIELD,
9563 Self::EXTRA_FIELDS_FIELD,
9564 ];
9565 }
9566 impl SystemState {
9567 pub fn path_builder() -> SystemStateFieldPathBuilder {
9568 SystemStateFieldPathBuilder::new()
9569 }
9570 }
9571 pub struct SystemStateFieldPathBuilder {
9572 path: Vec<&'static str>,
9573 }
9574 impl SystemStateFieldPathBuilder {
9575 #[allow(clippy::new_without_default)]
9576 pub fn new() -> Self {
9577 Self { path: Default::default() }
9578 }
9579 #[doc(hidden)]
9580 pub fn new_with_base(base: Vec<&'static str>) -> Self {
9581 Self { path: base }
9582 }
9583 pub fn finish(self) -> String {
9584 self.path.join(".")
9585 }
9586 pub fn version(mut self) -> String {
9587 self.path.push(SystemState::VERSION_FIELD.name);
9588 self.finish()
9589 }
9590 pub fn epoch(mut self) -> String {
9591 self.path.push(SystemState::EPOCH_FIELD.name);
9592 self.finish()
9593 }
9594 pub fn protocol_version(mut self) -> String {
9595 self.path.push(SystemState::PROTOCOL_VERSION_FIELD.name);
9596 self.finish()
9597 }
9598 pub fn validators(mut self) -> ValidatorSetFieldPathBuilder {
9599 self.path.push(SystemState::VALIDATORS_FIELD.name);
9600 ValidatorSetFieldPathBuilder::new_with_base(self.path)
9601 }
9602 pub fn storage_fund(mut self) -> StorageFundFieldPathBuilder {
9603 self.path.push(SystemState::STORAGE_FUND_FIELD.name);
9604 StorageFundFieldPathBuilder::new_with_base(self.path)
9605 }
9606 pub fn parameters(mut self) -> SystemParametersFieldPathBuilder {
9607 self.path.push(SystemState::PARAMETERS_FIELD.name);
9608 SystemParametersFieldPathBuilder::new_with_base(self.path)
9609 }
9610 pub fn reference_gas_price(mut self) -> String {
9611 self.path.push(SystemState::REFERENCE_GAS_PRICE_FIELD.name);
9612 self.finish()
9613 }
9614 pub fn validator_report_records(
9615 mut self,
9616 ) -> ValidatorReportRecordFieldPathBuilder {
9617 self.path.push(SystemState::VALIDATOR_REPORT_RECORDS_FIELD.name);
9618 ValidatorReportRecordFieldPathBuilder::new_with_base(self.path)
9619 }
9620 pub fn stake_subsidy(mut self) -> StakeSubsidyFieldPathBuilder {
9621 self.path.push(SystemState::STAKE_SUBSIDY_FIELD.name);
9622 StakeSubsidyFieldPathBuilder::new_with_base(self.path)
9623 }
9624 pub fn safe_mode(mut self) -> String {
9625 self.path.push(SystemState::SAFE_MODE_FIELD.name);
9626 self.finish()
9627 }
9628 pub fn safe_mode_storage_rewards(mut self) -> String {
9629 self.path.push(SystemState::SAFE_MODE_STORAGE_REWARDS_FIELD.name);
9630 self.finish()
9631 }
9632 pub fn safe_mode_computation_rewards(mut self) -> String {
9633 self.path.push(SystemState::SAFE_MODE_COMPUTATION_REWARDS_FIELD.name);
9634 self.finish()
9635 }
9636 pub fn safe_mode_storage_rebates(mut self) -> String {
9637 self.path.push(SystemState::SAFE_MODE_STORAGE_REBATES_FIELD.name);
9638 self.finish()
9639 }
9640 pub fn safe_mode_non_refundable_storage_fee(mut self) -> String {
9641 self.path.push(SystemState::SAFE_MODE_NON_REFUNDABLE_STORAGE_FEE_FIELD.name);
9642 self.finish()
9643 }
9644 pub fn epoch_start_timestamp_ms(mut self) -> String {
9645 self.path.push(SystemState::EPOCH_START_TIMESTAMP_MS_FIELD.name);
9646 self.finish()
9647 }
9648 pub fn extra_fields(mut self) -> MoveTableFieldPathBuilder {
9649 self.path.push(SystemState::EXTRA_FIELDS_FIELD.name);
9650 MoveTableFieldPathBuilder::new_with_base(self.path)
9651 }
9652 }
9653 impl ValidatorReportRecord {
9654 pub const REPORTED_FIELD: &'static MessageField = &MessageField {
9655 name: "reported",
9656 json_name: "reported",
9657 number: 1i32,
9658 message_fields: None,
9659 };
9660 pub const REPORTERS_FIELD: &'static MessageField = &MessageField {
9661 name: "reporters",
9662 json_name: "reporters",
9663 number: 2i32,
9664 message_fields: None,
9665 };
9666 }
9667 impl MessageFields for ValidatorReportRecord {
9668 const FIELDS: &'static [&'static MessageField] = &[
9669 Self::REPORTED_FIELD,
9670 Self::REPORTERS_FIELD,
9671 ];
9672 }
9673 impl ValidatorReportRecord {
9674 pub fn path_builder() -> ValidatorReportRecordFieldPathBuilder {
9675 ValidatorReportRecordFieldPathBuilder::new()
9676 }
9677 }
9678 pub struct ValidatorReportRecordFieldPathBuilder {
9679 path: Vec<&'static str>,
9680 }
9681 impl ValidatorReportRecordFieldPathBuilder {
9682 #[allow(clippy::new_without_default)]
9683 pub fn new() -> Self {
9684 Self { path: Default::default() }
9685 }
9686 #[doc(hidden)]
9687 pub fn new_with_base(base: Vec<&'static str>) -> Self {
9688 Self { path: base }
9689 }
9690 pub fn finish(self) -> String {
9691 self.path.join(".")
9692 }
9693 pub fn reported(mut self) -> String {
9694 self.path.push(ValidatorReportRecord::REPORTED_FIELD.name);
9695 self.finish()
9696 }
9697 pub fn reporters(mut self) -> String {
9698 self.path.push(ValidatorReportRecord::REPORTERS_FIELD.name);
9699 self.finish()
9700 }
9701 }
9702 impl SystemParameters {
9703 pub const EPOCH_DURATION_MS_FIELD: &'static MessageField = &MessageField {
9704 name: "epoch_duration_ms",
9705 json_name: "epochDurationMs",
9706 number: 1i32,
9707 message_fields: None,
9708 };
9709 pub const STAKE_SUBSIDY_START_EPOCH_FIELD: &'static MessageField = &MessageField {
9710 name: "stake_subsidy_start_epoch",
9711 json_name: "stakeSubsidyStartEpoch",
9712 number: 2i32,
9713 message_fields: None,
9714 };
9715 pub const MIN_VALIDATOR_COUNT_FIELD: &'static MessageField = &MessageField {
9716 name: "min_validator_count",
9717 json_name: "minValidatorCount",
9718 number: 3i32,
9719 message_fields: None,
9720 };
9721 pub const MAX_VALIDATOR_COUNT_FIELD: &'static MessageField = &MessageField {
9722 name: "max_validator_count",
9723 json_name: "maxValidatorCount",
9724 number: 4i32,
9725 message_fields: None,
9726 };
9727 pub const MIN_VALIDATOR_JOINING_STAKE_FIELD: &'static MessageField = &MessageField {
9728 name: "min_validator_joining_stake",
9729 json_name: "minValidatorJoiningStake",
9730 number: 5i32,
9731 message_fields: None,
9732 };
9733 pub const VALIDATOR_LOW_STAKE_THRESHOLD_FIELD: &'static MessageField = &MessageField {
9734 name: "validator_low_stake_threshold",
9735 json_name: "validatorLowStakeThreshold",
9736 number: 6i32,
9737 message_fields: None,
9738 };
9739 pub const VALIDATOR_VERY_LOW_STAKE_THRESHOLD_FIELD: &'static MessageField = &MessageField {
9740 name: "validator_very_low_stake_threshold",
9741 json_name: "validatorVeryLowStakeThreshold",
9742 number: 7i32,
9743 message_fields: None,
9744 };
9745 pub const VALIDATOR_LOW_STAKE_GRACE_PERIOD_FIELD: &'static MessageField = &MessageField {
9746 name: "validator_low_stake_grace_period",
9747 json_name: "validatorLowStakeGracePeriod",
9748 number: 8i32,
9749 message_fields: None,
9750 };
9751 pub const EXTRA_FIELDS_FIELD: &'static MessageField = &MessageField {
9752 name: "extra_fields",
9753 json_name: "extraFields",
9754 number: 9i32,
9755 message_fields: Some(MoveTable::FIELDS),
9756 };
9757 }
9758 impl MessageFields for SystemParameters {
9759 const FIELDS: &'static [&'static MessageField] = &[
9760 Self::EPOCH_DURATION_MS_FIELD,
9761 Self::STAKE_SUBSIDY_START_EPOCH_FIELD,
9762 Self::MIN_VALIDATOR_COUNT_FIELD,
9763 Self::MAX_VALIDATOR_COUNT_FIELD,
9764 Self::MIN_VALIDATOR_JOINING_STAKE_FIELD,
9765 Self::VALIDATOR_LOW_STAKE_THRESHOLD_FIELD,
9766 Self::VALIDATOR_VERY_LOW_STAKE_THRESHOLD_FIELD,
9767 Self::VALIDATOR_LOW_STAKE_GRACE_PERIOD_FIELD,
9768 Self::EXTRA_FIELDS_FIELD,
9769 ];
9770 }
9771 impl SystemParameters {
9772 pub fn path_builder() -> SystemParametersFieldPathBuilder {
9773 SystemParametersFieldPathBuilder::new()
9774 }
9775 }
9776 pub struct SystemParametersFieldPathBuilder {
9777 path: Vec<&'static str>,
9778 }
9779 impl SystemParametersFieldPathBuilder {
9780 #[allow(clippy::new_without_default)]
9781 pub fn new() -> Self {
9782 Self { path: Default::default() }
9783 }
9784 #[doc(hidden)]
9785 pub fn new_with_base(base: Vec<&'static str>) -> Self {
9786 Self { path: base }
9787 }
9788 pub fn finish(self) -> String {
9789 self.path.join(".")
9790 }
9791 pub fn epoch_duration_ms(mut self) -> String {
9792 self.path.push(SystemParameters::EPOCH_DURATION_MS_FIELD.name);
9793 self.finish()
9794 }
9795 pub fn stake_subsidy_start_epoch(mut self) -> String {
9796 self.path.push(SystemParameters::STAKE_SUBSIDY_START_EPOCH_FIELD.name);
9797 self.finish()
9798 }
9799 pub fn min_validator_count(mut self) -> String {
9800 self.path.push(SystemParameters::MIN_VALIDATOR_COUNT_FIELD.name);
9801 self.finish()
9802 }
9803 pub fn max_validator_count(mut self) -> String {
9804 self.path.push(SystemParameters::MAX_VALIDATOR_COUNT_FIELD.name);
9805 self.finish()
9806 }
9807 pub fn min_validator_joining_stake(mut self) -> String {
9808 self.path.push(SystemParameters::MIN_VALIDATOR_JOINING_STAKE_FIELD.name);
9809 self.finish()
9810 }
9811 pub fn validator_low_stake_threshold(mut self) -> String {
9812 self.path.push(SystemParameters::VALIDATOR_LOW_STAKE_THRESHOLD_FIELD.name);
9813 self.finish()
9814 }
9815 pub fn validator_very_low_stake_threshold(mut self) -> String {
9816 self.path
9817 .push(SystemParameters::VALIDATOR_VERY_LOW_STAKE_THRESHOLD_FIELD.name);
9818 self.finish()
9819 }
9820 pub fn validator_low_stake_grace_period(mut self) -> String {
9821 self.path
9822 .push(SystemParameters::VALIDATOR_LOW_STAKE_GRACE_PERIOD_FIELD.name);
9823 self.finish()
9824 }
9825 pub fn extra_fields(mut self) -> MoveTableFieldPathBuilder {
9826 self.path.push(SystemParameters::EXTRA_FIELDS_FIELD.name);
9827 MoveTableFieldPathBuilder::new_with_base(self.path)
9828 }
9829 }
9830 impl MoveTable {
9831 pub const ID_FIELD: &'static MessageField = &MessageField {
9832 name: "id",
9833 json_name: "id",
9834 number: 1i32,
9835 message_fields: None,
9836 };
9837 pub const SIZE_FIELD: &'static MessageField = &MessageField {
9838 name: "size",
9839 json_name: "size",
9840 number: 2i32,
9841 message_fields: None,
9842 };
9843 }
9844 impl MessageFields for MoveTable {
9845 const FIELDS: &'static [&'static MessageField] = &[
9846 Self::ID_FIELD,
9847 Self::SIZE_FIELD,
9848 ];
9849 }
9850 impl MoveTable {
9851 pub fn path_builder() -> MoveTableFieldPathBuilder {
9852 MoveTableFieldPathBuilder::new()
9853 }
9854 }
9855 pub struct MoveTableFieldPathBuilder {
9856 path: Vec<&'static str>,
9857 }
9858 impl MoveTableFieldPathBuilder {
9859 #[allow(clippy::new_without_default)]
9860 pub fn new() -> Self {
9861 Self { path: Default::default() }
9862 }
9863 #[doc(hidden)]
9864 pub fn new_with_base(base: Vec<&'static str>) -> Self {
9865 Self { path: base }
9866 }
9867 pub fn finish(self) -> String {
9868 self.path.join(".")
9869 }
9870 pub fn id(mut self) -> String {
9871 self.path.push(MoveTable::ID_FIELD.name);
9872 self.finish()
9873 }
9874 pub fn size(mut self) -> String {
9875 self.path.push(MoveTable::SIZE_FIELD.name);
9876 self.finish()
9877 }
9878 }
9879 impl StakeSubsidy {
9880 pub const BALANCE_FIELD: &'static MessageField = &MessageField {
9881 name: "balance",
9882 json_name: "balance",
9883 number: 1i32,
9884 message_fields: None,
9885 };
9886 pub const DISTRIBUTION_COUNTER_FIELD: &'static MessageField = &MessageField {
9887 name: "distribution_counter",
9888 json_name: "distributionCounter",
9889 number: 2i32,
9890 message_fields: None,
9891 };
9892 pub const CURRENT_DISTRIBUTION_AMOUNT_FIELD: &'static MessageField = &MessageField {
9893 name: "current_distribution_amount",
9894 json_name: "currentDistributionAmount",
9895 number: 3i32,
9896 message_fields: None,
9897 };
9898 pub const STAKE_SUBSIDY_PERIOD_LENGTH_FIELD: &'static MessageField = &MessageField {
9899 name: "stake_subsidy_period_length",
9900 json_name: "stakeSubsidyPeriodLength",
9901 number: 4i32,
9902 message_fields: None,
9903 };
9904 pub const STAKE_SUBSIDY_DECREASE_RATE_FIELD: &'static MessageField = &MessageField {
9905 name: "stake_subsidy_decrease_rate",
9906 json_name: "stakeSubsidyDecreaseRate",
9907 number: 5i32,
9908 message_fields: None,
9909 };
9910 pub const EXTRA_FIELDS_FIELD: &'static MessageField = &MessageField {
9911 name: "extra_fields",
9912 json_name: "extraFields",
9913 number: 6i32,
9914 message_fields: Some(MoveTable::FIELDS),
9915 };
9916 }
9917 impl MessageFields for StakeSubsidy {
9918 const FIELDS: &'static [&'static MessageField] = &[
9919 Self::BALANCE_FIELD,
9920 Self::DISTRIBUTION_COUNTER_FIELD,
9921 Self::CURRENT_DISTRIBUTION_AMOUNT_FIELD,
9922 Self::STAKE_SUBSIDY_PERIOD_LENGTH_FIELD,
9923 Self::STAKE_SUBSIDY_DECREASE_RATE_FIELD,
9924 Self::EXTRA_FIELDS_FIELD,
9925 ];
9926 }
9927 impl StakeSubsidy {
9928 pub fn path_builder() -> StakeSubsidyFieldPathBuilder {
9929 StakeSubsidyFieldPathBuilder::new()
9930 }
9931 }
9932 pub struct StakeSubsidyFieldPathBuilder {
9933 path: Vec<&'static str>,
9934 }
9935 impl StakeSubsidyFieldPathBuilder {
9936 #[allow(clippy::new_without_default)]
9937 pub fn new() -> Self {
9938 Self { path: Default::default() }
9939 }
9940 #[doc(hidden)]
9941 pub fn new_with_base(base: Vec<&'static str>) -> Self {
9942 Self { path: base }
9943 }
9944 pub fn finish(self) -> String {
9945 self.path.join(".")
9946 }
9947 pub fn balance(mut self) -> String {
9948 self.path.push(StakeSubsidy::BALANCE_FIELD.name);
9949 self.finish()
9950 }
9951 pub fn distribution_counter(mut self) -> String {
9952 self.path.push(StakeSubsidy::DISTRIBUTION_COUNTER_FIELD.name);
9953 self.finish()
9954 }
9955 pub fn current_distribution_amount(mut self) -> String {
9956 self.path.push(StakeSubsidy::CURRENT_DISTRIBUTION_AMOUNT_FIELD.name);
9957 self.finish()
9958 }
9959 pub fn stake_subsidy_period_length(mut self) -> String {
9960 self.path.push(StakeSubsidy::STAKE_SUBSIDY_PERIOD_LENGTH_FIELD.name);
9961 self.finish()
9962 }
9963 pub fn stake_subsidy_decrease_rate(mut self) -> String {
9964 self.path.push(StakeSubsidy::STAKE_SUBSIDY_DECREASE_RATE_FIELD.name);
9965 self.finish()
9966 }
9967 pub fn extra_fields(mut self) -> MoveTableFieldPathBuilder {
9968 self.path.push(StakeSubsidy::EXTRA_FIELDS_FIELD.name);
9969 MoveTableFieldPathBuilder::new_with_base(self.path)
9970 }
9971 }
9972 impl StorageFund {
9973 pub const TOTAL_OBJECT_STORAGE_REBATES_FIELD: &'static MessageField = &MessageField {
9974 name: "total_object_storage_rebates",
9975 json_name: "totalObjectStorageRebates",
9976 number: 1i32,
9977 message_fields: None,
9978 };
9979 pub const NON_REFUNDABLE_BALANCE_FIELD: &'static MessageField = &MessageField {
9980 name: "non_refundable_balance",
9981 json_name: "nonRefundableBalance",
9982 number: 2i32,
9983 message_fields: None,
9984 };
9985 }
9986 impl MessageFields for StorageFund {
9987 const FIELDS: &'static [&'static MessageField] = &[
9988 Self::TOTAL_OBJECT_STORAGE_REBATES_FIELD,
9989 Self::NON_REFUNDABLE_BALANCE_FIELD,
9990 ];
9991 }
9992 impl StorageFund {
9993 pub fn path_builder() -> StorageFundFieldPathBuilder {
9994 StorageFundFieldPathBuilder::new()
9995 }
9996 }
9997 pub struct StorageFundFieldPathBuilder {
9998 path: Vec<&'static str>,
9999 }
10000 impl StorageFundFieldPathBuilder {
10001 #[allow(clippy::new_without_default)]
10002 pub fn new() -> Self {
10003 Self { path: Default::default() }
10004 }
10005 #[doc(hidden)]
10006 pub fn new_with_base(base: Vec<&'static str>) -> Self {
10007 Self { path: base }
10008 }
10009 pub fn finish(self) -> String {
10010 self.path.join(".")
10011 }
10012 pub fn total_object_storage_rebates(mut self) -> String {
10013 self.path.push(StorageFund::TOTAL_OBJECT_STORAGE_REBATES_FIELD.name);
10014 self.finish()
10015 }
10016 pub fn non_refundable_balance(mut self) -> String {
10017 self.path.push(StorageFund::NON_REFUNDABLE_BALANCE_FIELD.name);
10018 self.finish()
10019 }
10020 }
10021 impl ValidatorSet {
10022 pub const TOTAL_STAKE_FIELD: &'static MessageField = &MessageField {
10023 name: "total_stake",
10024 json_name: "totalStake",
10025 number: 1i32,
10026 message_fields: None,
10027 };
10028 pub const ACTIVE_VALIDATORS_FIELD: &'static MessageField = &MessageField {
10029 name: "active_validators",
10030 json_name: "activeValidators",
10031 number: 2i32,
10032 message_fields: Some(Validator::FIELDS),
10033 };
10034 pub const PENDING_ACTIVE_VALIDATORS_FIELD: &'static MessageField = &MessageField {
10035 name: "pending_active_validators",
10036 json_name: "pendingActiveValidators",
10037 number: 3i32,
10038 message_fields: Some(MoveTable::FIELDS),
10039 };
10040 pub const PENDING_REMOVALS_FIELD: &'static MessageField = &MessageField {
10041 name: "pending_removals",
10042 json_name: "pendingRemovals",
10043 number: 4i32,
10044 message_fields: None,
10045 };
10046 pub const STAKING_POOL_MAPPINGS_FIELD: &'static MessageField = &MessageField {
10047 name: "staking_pool_mappings",
10048 json_name: "stakingPoolMappings",
10049 number: 5i32,
10050 message_fields: Some(MoveTable::FIELDS),
10051 };
10052 pub const INACTIVE_VALIDATORS_FIELD: &'static MessageField = &MessageField {
10053 name: "inactive_validators",
10054 json_name: "inactiveValidators",
10055 number: 6i32,
10056 message_fields: Some(MoveTable::FIELDS),
10057 };
10058 pub const VALIDATOR_CANDIDATES_FIELD: &'static MessageField = &MessageField {
10059 name: "validator_candidates",
10060 json_name: "validatorCandidates",
10061 number: 7i32,
10062 message_fields: Some(MoveTable::FIELDS),
10063 };
10064 pub const AT_RISK_VALIDATORS_FIELD: &'static MessageField = &MessageField {
10065 name: "at_risk_validators",
10066 json_name: "atRiskValidators",
10067 number: 8i32,
10068 message_fields: None,
10069 };
10070 pub const EXTRA_FIELDS_FIELD: &'static MessageField = &MessageField {
10071 name: "extra_fields",
10072 json_name: "extraFields",
10073 number: 9i32,
10074 message_fields: Some(MoveTable::FIELDS),
10075 };
10076 }
10077 impl MessageFields for ValidatorSet {
10078 const FIELDS: &'static [&'static MessageField] = &[
10079 Self::TOTAL_STAKE_FIELD,
10080 Self::ACTIVE_VALIDATORS_FIELD,
10081 Self::PENDING_ACTIVE_VALIDATORS_FIELD,
10082 Self::PENDING_REMOVALS_FIELD,
10083 Self::STAKING_POOL_MAPPINGS_FIELD,
10084 Self::INACTIVE_VALIDATORS_FIELD,
10085 Self::VALIDATOR_CANDIDATES_FIELD,
10086 Self::AT_RISK_VALIDATORS_FIELD,
10087 Self::EXTRA_FIELDS_FIELD,
10088 ];
10089 }
10090 impl ValidatorSet {
10091 pub fn path_builder() -> ValidatorSetFieldPathBuilder {
10092 ValidatorSetFieldPathBuilder::new()
10093 }
10094 }
10095 pub struct ValidatorSetFieldPathBuilder {
10096 path: Vec<&'static str>,
10097 }
10098 impl ValidatorSetFieldPathBuilder {
10099 #[allow(clippy::new_without_default)]
10100 pub fn new() -> Self {
10101 Self { path: Default::default() }
10102 }
10103 #[doc(hidden)]
10104 pub fn new_with_base(base: Vec<&'static str>) -> Self {
10105 Self { path: base }
10106 }
10107 pub fn finish(self) -> String {
10108 self.path.join(".")
10109 }
10110 pub fn total_stake(mut self) -> String {
10111 self.path.push(ValidatorSet::TOTAL_STAKE_FIELD.name);
10112 self.finish()
10113 }
10114 pub fn active_validators(mut self) -> ValidatorFieldPathBuilder {
10115 self.path.push(ValidatorSet::ACTIVE_VALIDATORS_FIELD.name);
10116 ValidatorFieldPathBuilder::new_with_base(self.path)
10117 }
10118 pub fn pending_active_validators(mut self) -> MoveTableFieldPathBuilder {
10119 self.path.push(ValidatorSet::PENDING_ACTIVE_VALIDATORS_FIELD.name);
10120 MoveTableFieldPathBuilder::new_with_base(self.path)
10121 }
10122 pub fn pending_removals(mut self) -> String {
10123 self.path.push(ValidatorSet::PENDING_REMOVALS_FIELD.name);
10124 self.finish()
10125 }
10126 pub fn staking_pool_mappings(mut self) -> MoveTableFieldPathBuilder {
10127 self.path.push(ValidatorSet::STAKING_POOL_MAPPINGS_FIELD.name);
10128 MoveTableFieldPathBuilder::new_with_base(self.path)
10129 }
10130 pub fn inactive_validators(mut self) -> MoveTableFieldPathBuilder {
10131 self.path.push(ValidatorSet::INACTIVE_VALIDATORS_FIELD.name);
10132 MoveTableFieldPathBuilder::new_with_base(self.path)
10133 }
10134 pub fn validator_candidates(mut self) -> MoveTableFieldPathBuilder {
10135 self.path.push(ValidatorSet::VALIDATOR_CANDIDATES_FIELD.name);
10136 MoveTableFieldPathBuilder::new_with_base(self.path)
10137 }
10138 pub fn at_risk_validators(mut self) -> String {
10139 self.path.push(ValidatorSet::AT_RISK_VALIDATORS_FIELD.name);
10140 self.finish()
10141 }
10142 pub fn extra_fields(mut self) -> MoveTableFieldPathBuilder {
10143 self.path.push(ValidatorSet::EXTRA_FIELDS_FIELD.name);
10144 MoveTableFieldPathBuilder::new_with_base(self.path)
10145 }
10146 }
10147 impl Validator {
10148 pub const NAME_FIELD: &'static MessageField = &MessageField {
10149 name: "name",
10150 json_name: "name",
10151 number: 1i32,
10152 message_fields: None,
10153 };
10154 pub const ADDRESS_FIELD: &'static MessageField = &MessageField {
10155 name: "address",
10156 json_name: "address",
10157 number: 2i32,
10158 message_fields: None,
10159 };
10160 pub const DESCRIPTION_FIELD: &'static MessageField = &MessageField {
10161 name: "description",
10162 json_name: "description",
10163 number: 3i32,
10164 message_fields: None,
10165 };
10166 pub const IMAGE_URL_FIELD: &'static MessageField = &MessageField {
10167 name: "image_url",
10168 json_name: "imageUrl",
10169 number: 4i32,
10170 message_fields: None,
10171 };
10172 pub const PROJECT_URL_FIELD: &'static MessageField = &MessageField {
10173 name: "project_url",
10174 json_name: "projectUrl",
10175 number: 5i32,
10176 message_fields: None,
10177 };
10178 pub const PROTOCOL_PUBLIC_KEY_FIELD: &'static MessageField = &MessageField {
10179 name: "protocol_public_key",
10180 json_name: "protocolPublicKey",
10181 number: 7i32,
10182 message_fields: None,
10183 };
10184 pub const PROOF_OF_POSSESSION_FIELD: &'static MessageField = &MessageField {
10185 name: "proof_of_possession",
10186 json_name: "proofOfPossession",
10187 number: 8i32,
10188 message_fields: None,
10189 };
10190 pub const NETWORK_PUBLIC_KEY_FIELD: &'static MessageField = &MessageField {
10191 name: "network_public_key",
10192 json_name: "networkPublicKey",
10193 number: 10i32,
10194 message_fields: None,
10195 };
10196 pub const WORKER_PUBLIC_KEY_FIELD: &'static MessageField = &MessageField {
10197 name: "worker_public_key",
10198 json_name: "workerPublicKey",
10199 number: 12i32,
10200 message_fields: None,
10201 };
10202 pub const NETWORK_ADDRESS_FIELD: &'static MessageField = &MessageField {
10203 name: "network_address",
10204 json_name: "networkAddress",
10205 number: 13i32,
10206 message_fields: None,
10207 };
10208 pub const P2P_ADDRESS_FIELD: &'static MessageField = &MessageField {
10209 name: "p2p_address",
10210 json_name: "p2pAddress",
10211 number: 14i32,
10212 message_fields: None,
10213 };
10214 pub const PRIMARY_ADDRESS_FIELD: &'static MessageField = &MessageField {
10215 name: "primary_address",
10216 json_name: "primaryAddress",
10217 number: 15i32,
10218 message_fields: None,
10219 };
10220 pub const WORKER_ADDRESS_FIELD: &'static MessageField = &MessageField {
10221 name: "worker_address",
10222 json_name: "workerAddress",
10223 number: 16i32,
10224 message_fields: None,
10225 };
10226 pub const NEXT_EPOCH_PROTOCOL_PUBLIC_KEY_FIELD: &'static MessageField = &MessageField {
10227 name: "next_epoch_protocol_public_key",
10228 json_name: "nextEpochProtocolPublicKey",
10229 number: 18i32,
10230 message_fields: None,
10231 };
10232 pub const NEXT_EPOCH_PROOF_OF_POSSESSION_FIELD: &'static MessageField = &MessageField {
10233 name: "next_epoch_proof_of_possession",
10234 json_name: "nextEpochProofOfPossession",
10235 number: 19i32,
10236 message_fields: None,
10237 };
10238 pub const NEXT_EPOCH_NETWORK_PUBLIC_KEY_FIELD: &'static MessageField = &MessageField {
10239 name: "next_epoch_network_public_key",
10240 json_name: "nextEpochNetworkPublicKey",
10241 number: 21i32,
10242 message_fields: None,
10243 };
10244 pub const NEXT_EPOCH_WORKER_PUBLIC_KEY_FIELD: &'static MessageField = &MessageField {
10245 name: "next_epoch_worker_public_key",
10246 json_name: "nextEpochWorkerPublicKey",
10247 number: 23i32,
10248 message_fields: None,
10249 };
10250 pub const NEXT_EPOCH_NETWORK_ADDRESS_FIELD: &'static MessageField = &MessageField {
10251 name: "next_epoch_network_address",
10252 json_name: "nextEpochNetworkAddress",
10253 number: 24i32,
10254 message_fields: None,
10255 };
10256 pub const NEXT_EPOCH_P2P_ADDRESS_FIELD: &'static MessageField = &MessageField {
10257 name: "next_epoch_p2p_address",
10258 json_name: "nextEpochP2pAddress",
10259 number: 25i32,
10260 message_fields: None,
10261 };
10262 pub const NEXT_EPOCH_PRIMARY_ADDRESS_FIELD: &'static MessageField = &MessageField {
10263 name: "next_epoch_primary_address",
10264 json_name: "nextEpochPrimaryAddress",
10265 number: 26i32,
10266 message_fields: None,
10267 };
10268 pub const NEXT_EPOCH_WORKER_ADDRESS_FIELD: &'static MessageField = &MessageField {
10269 name: "next_epoch_worker_address",
10270 json_name: "nextEpochWorkerAddress",
10271 number: 27i32,
10272 message_fields: None,
10273 };
10274 pub const METADATA_EXTRA_FIELDS_FIELD: &'static MessageField = &MessageField {
10275 name: "metadata_extra_fields",
10276 json_name: "metadataExtraFields",
10277 number: 28i32,
10278 message_fields: Some(MoveTable::FIELDS),
10279 };
10280 pub const VOTING_POWER_FIELD: &'static MessageField = &MessageField {
10281 name: "voting_power",
10282 json_name: "votingPower",
10283 number: 29i32,
10284 message_fields: None,
10285 };
10286 pub const OPERATION_CAP_ID_FIELD: &'static MessageField = &MessageField {
10287 name: "operation_cap_id",
10288 json_name: "operationCapId",
10289 number: 30i32,
10290 message_fields: None,
10291 };
10292 pub const GAS_PRICE_FIELD: &'static MessageField = &MessageField {
10293 name: "gas_price",
10294 json_name: "gasPrice",
10295 number: 31i32,
10296 message_fields: None,
10297 };
10298 pub const STAKING_POOL_FIELD: &'static MessageField = &MessageField {
10299 name: "staking_pool",
10300 json_name: "stakingPool",
10301 number: 32i32,
10302 message_fields: Some(StakingPool::FIELDS),
10303 };
10304 pub const COMMISSION_RATE_FIELD: &'static MessageField = &MessageField {
10305 name: "commission_rate",
10306 json_name: "commissionRate",
10307 number: 33i32,
10308 message_fields: None,
10309 };
10310 pub const NEXT_EPOCH_STAKE_FIELD: &'static MessageField = &MessageField {
10311 name: "next_epoch_stake",
10312 json_name: "nextEpochStake",
10313 number: 34i32,
10314 message_fields: None,
10315 };
10316 pub const NEXT_EPOCH_GAS_PRICE_FIELD: &'static MessageField = &MessageField {
10317 name: "next_epoch_gas_price",
10318 json_name: "nextEpochGasPrice",
10319 number: 35i32,
10320 message_fields: None,
10321 };
10322 pub const NEXT_EPOCH_COMMISSION_RATE_FIELD: &'static MessageField = &MessageField {
10323 name: "next_epoch_commission_rate",
10324 json_name: "nextEpochCommissionRate",
10325 number: 36i32,
10326 message_fields: None,
10327 };
10328 pub const EXTRA_FIELDS_FIELD: &'static MessageField = &MessageField {
10329 name: "extra_fields",
10330 json_name: "extraFields",
10331 number: 37i32,
10332 message_fields: Some(MoveTable::FIELDS),
10333 };
10334 }
10335 impl MessageFields for Validator {
10336 const FIELDS: &'static [&'static MessageField] = &[
10337 Self::NAME_FIELD,
10338 Self::ADDRESS_FIELD,
10339 Self::DESCRIPTION_FIELD,
10340 Self::IMAGE_URL_FIELD,
10341 Self::PROJECT_URL_FIELD,
10342 Self::PROTOCOL_PUBLIC_KEY_FIELD,
10343 Self::PROOF_OF_POSSESSION_FIELD,
10344 Self::NETWORK_PUBLIC_KEY_FIELD,
10345 Self::WORKER_PUBLIC_KEY_FIELD,
10346 Self::NETWORK_ADDRESS_FIELD,
10347 Self::P2P_ADDRESS_FIELD,
10348 Self::PRIMARY_ADDRESS_FIELD,
10349 Self::WORKER_ADDRESS_FIELD,
10350 Self::NEXT_EPOCH_PROTOCOL_PUBLIC_KEY_FIELD,
10351 Self::NEXT_EPOCH_PROOF_OF_POSSESSION_FIELD,
10352 Self::NEXT_EPOCH_NETWORK_PUBLIC_KEY_FIELD,
10353 Self::NEXT_EPOCH_WORKER_PUBLIC_KEY_FIELD,
10354 Self::NEXT_EPOCH_NETWORK_ADDRESS_FIELD,
10355 Self::NEXT_EPOCH_P2P_ADDRESS_FIELD,
10356 Self::NEXT_EPOCH_PRIMARY_ADDRESS_FIELD,
10357 Self::NEXT_EPOCH_WORKER_ADDRESS_FIELD,
10358 Self::METADATA_EXTRA_FIELDS_FIELD,
10359 Self::VOTING_POWER_FIELD,
10360 Self::OPERATION_CAP_ID_FIELD,
10361 Self::GAS_PRICE_FIELD,
10362 Self::STAKING_POOL_FIELD,
10363 Self::COMMISSION_RATE_FIELD,
10364 Self::NEXT_EPOCH_STAKE_FIELD,
10365 Self::NEXT_EPOCH_GAS_PRICE_FIELD,
10366 Self::NEXT_EPOCH_COMMISSION_RATE_FIELD,
10367 Self::EXTRA_FIELDS_FIELD,
10368 ];
10369 }
10370 impl Validator {
10371 pub fn path_builder() -> ValidatorFieldPathBuilder {
10372 ValidatorFieldPathBuilder::new()
10373 }
10374 }
10375 pub struct ValidatorFieldPathBuilder {
10376 path: Vec<&'static str>,
10377 }
10378 impl ValidatorFieldPathBuilder {
10379 #[allow(clippy::new_without_default)]
10380 pub fn new() -> Self {
10381 Self { path: Default::default() }
10382 }
10383 #[doc(hidden)]
10384 pub fn new_with_base(base: Vec<&'static str>) -> Self {
10385 Self { path: base }
10386 }
10387 pub fn finish(self) -> String {
10388 self.path.join(".")
10389 }
10390 pub fn name(mut self) -> String {
10391 self.path.push(Validator::NAME_FIELD.name);
10392 self.finish()
10393 }
10394 pub fn address(mut self) -> String {
10395 self.path.push(Validator::ADDRESS_FIELD.name);
10396 self.finish()
10397 }
10398 pub fn description(mut self) -> String {
10399 self.path.push(Validator::DESCRIPTION_FIELD.name);
10400 self.finish()
10401 }
10402 pub fn image_url(mut self) -> String {
10403 self.path.push(Validator::IMAGE_URL_FIELD.name);
10404 self.finish()
10405 }
10406 pub fn project_url(mut self) -> String {
10407 self.path.push(Validator::PROJECT_URL_FIELD.name);
10408 self.finish()
10409 }
10410 pub fn protocol_public_key(mut self) -> String {
10411 self.path.push(Validator::PROTOCOL_PUBLIC_KEY_FIELD.name);
10412 self.finish()
10413 }
10414 pub fn proof_of_possession(mut self) -> String {
10415 self.path.push(Validator::PROOF_OF_POSSESSION_FIELD.name);
10416 self.finish()
10417 }
10418 pub fn network_public_key(mut self) -> String {
10419 self.path.push(Validator::NETWORK_PUBLIC_KEY_FIELD.name);
10420 self.finish()
10421 }
10422 pub fn worker_public_key(mut self) -> String {
10423 self.path.push(Validator::WORKER_PUBLIC_KEY_FIELD.name);
10424 self.finish()
10425 }
10426 pub fn network_address(mut self) -> String {
10427 self.path.push(Validator::NETWORK_ADDRESS_FIELD.name);
10428 self.finish()
10429 }
10430 pub fn p2p_address(mut self) -> String {
10431 self.path.push(Validator::P2P_ADDRESS_FIELD.name);
10432 self.finish()
10433 }
10434 pub fn primary_address(mut self) -> String {
10435 self.path.push(Validator::PRIMARY_ADDRESS_FIELD.name);
10436 self.finish()
10437 }
10438 pub fn worker_address(mut self) -> String {
10439 self.path.push(Validator::WORKER_ADDRESS_FIELD.name);
10440 self.finish()
10441 }
10442 pub fn next_epoch_protocol_public_key(mut self) -> String {
10443 self.path.push(Validator::NEXT_EPOCH_PROTOCOL_PUBLIC_KEY_FIELD.name);
10444 self.finish()
10445 }
10446 pub fn next_epoch_proof_of_possession(mut self) -> String {
10447 self.path.push(Validator::NEXT_EPOCH_PROOF_OF_POSSESSION_FIELD.name);
10448 self.finish()
10449 }
10450 pub fn next_epoch_network_public_key(mut self) -> String {
10451 self.path.push(Validator::NEXT_EPOCH_NETWORK_PUBLIC_KEY_FIELD.name);
10452 self.finish()
10453 }
10454 pub fn next_epoch_worker_public_key(mut self) -> String {
10455 self.path.push(Validator::NEXT_EPOCH_WORKER_PUBLIC_KEY_FIELD.name);
10456 self.finish()
10457 }
10458 pub fn next_epoch_network_address(mut self) -> String {
10459 self.path.push(Validator::NEXT_EPOCH_NETWORK_ADDRESS_FIELD.name);
10460 self.finish()
10461 }
10462 pub fn next_epoch_p2p_address(mut self) -> String {
10463 self.path.push(Validator::NEXT_EPOCH_P2P_ADDRESS_FIELD.name);
10464 self.finish()
10465 }
10466 pub fn next_epoch_primary_address(mut self) -> String {
10467 self.path.push(Validator::NEXT_EPOCH_PRIMARY_ADDRESS_FIELD.name);
10468 self.finish()
10469 }
10470 pub fn next_epoch_worker_address(mut self) -> String {
10471 self.path.push(Validator::NEXT_EPOCH_WORKER_ADDRESS_FIELD.name);
10472 self.finish()
10473 }
10474 pub fn metadata_extra_fields(mut self) -> MoveTableFieldPathBuilder {
10475 self.path.push(Validator::METADATA_EXTRA_FIELDS_FIELD.name);
10476 MoveTableFieldPathBuilder::new_with_base(self.path)
10477 }
10478 pub fn voting_power(mut self) -> String {
10479 self.path.push(Validator::VOTING_POWER_FIELD.name);
10480 self.finish()
10481 }
10482 pub fn operation_cap_id(mut self) -> String {
10483 self.path.push(Validator::OPERATION_CAP_ID_FIELD.name);
10484 self.finish()
10485 }
10486 pub fn gas_price(mut self) -> String {
10487 self.path.push(Validator::GAS_PRICE_FIELD.name);
10488 self.finish()
10489 }
10490 pub fn staking_pool(mut self) -> StakingPoolFieldPathBuilder {
10491 self.path.push(Validator::STAKING_POOL_FIELD.name);
10492 StakingPoolFieldPathBuilder::new_with_base(self.path)
10493 }
10494 pub fn commission_rate(mut self) -> String {
10495 self.path.push(Validator::COMMISSION_RATE_FIELD.name);
10496 self.finish()
10497 }
10498 pub fn next_epoch_stake(mut self) -> String {
10499 self.path.push(Validator::NEXT_EPOCH_STAKE_FIELD.name);
10500 self.finish()
10501 }
10502 pub fn next_epoch_gas_price(mut self) -> String {
10503 self.path.push(Validator::NEXT_EPOCH_GAS_PRICE_FIELD.name);
10504 self.finish()
10505 }
10506 pub fn next_epoch_commission_rate(mut self) -> String {
10507 self.path.push(Validator::NEXT_EPOCH_COMMISSION_RATE_FIELD.name);
10508 self.finish()
10509 }
10510 pub fn extra_fields(mut self) -> MoveTableFieldPathBuilder {
10511 self.path.push(Validator::EXTRA_FIELDS_FIELD.name);
10512 MoveTableFieldPathBuilder::new_with_base(self.path)
10513 }
10514 }
10515 impl StakingPool {
10516 pub const ID_FIELD: &'static MessageField = &MessageField {
10517 name: "id",
10518 json_name: "id",
10519 number: 1i32,
10520 message_fields: None,
10521 };
10522 pub const ACTIVATION_EPOCH_FIELD: &'static MessageField = &MessageField {
10523 name: "activation_epoch",
10524 json_name: "activationEpoch",
10525 number: 2i32,
10526 message_fields: None,
10527 };
10528 pub const DEACTIVATION_EPOCH_FIELD: &'static MessageField = &MessageField {
10529 name: "deactivation_epoch",
10530 json_name: "deactivationEpoch",
10531 number: 3i32,
10532 message_fields: None,
10533 };
10534 pub const SUI_BALANCE_FIELD: &'static MessageField = &MessageField {
10535 name: "sui_balance",
10536 json_name: "suiBalance",
10537 number: 4i32,
10538 message_fields: None,
10539 };
10540 pub const REWARDS_POOL_FIELD: &'static MessageField = &MessageField {
10541 name: "rewards_pool",
10542 json_name: "rewardsPool",
10543 number: 5i32,
10544 message_fields: None,
10545 };
10546 pub const POOL_TOKEN_BALANCE_FIELD: &'static MessageField = &MessageField {
10547 name: "pool_token_balance",
10548 json_name: "poolTokenBalance",
10549 number: 6i32,
10550 message_fields: None,
10551 };
10552 pub const EXCHANGE_RATES_FIELD: &'static MessageField = &MessageField {
10553 name: "exchange_rates",
10554 json_name: "exchangeRates",
10555 number: 7i32,
10556 message_fields: Some(MoveTable::FIELDS),
10557 };
10558 pub const PENDING_STAKE_FIELD: &'static MessageField = &MessageField {
10559 name: "pending_stake",
10560 json_name: "pendingStake",
10561 number: 8i32,
10562 message_fields: None,
10563 };
10564 pub const PENDING_TOTAL_SUI_WITHDRAW_FIELD: &'static MessageField = &MessageField {
10565 name: "pending_total_sui_withdraw",
10566 json_name: "pendingTotalSuiWithdraw",
10567 number: 9i32,
10568 message_fields: None,
10569 };
10570 pub const PENDING_POOL_TOKEN_WITHDRAW_FIELD: &'static MessageField = &MessageField {
10571 name: "pending_pool_token_withdraw",
10572 json_name: "pendingPoolTokenWithdraw",
10573 number: 10i32,
10574 message_fields: None,
10575 };
10576 pub const EXTRA_FIELDS_FIELD: &'static MessageField = &MessageField {
10577 name: "extra_fields",
10578 json_name: "extraFields",
10579 number: 11i32,
10580 message_fields: Some(MoveTable::FIELDS),
10581 };
10582 }
10583 impl MessageFields for StakingPool {
10584 const FIELDS: &'static [&'static MessageField] = &[
10585 Self::ID_FIELD,
10586 Self::ACTIVATION_EPOCH_FIELD,
10587 Self::DEACTIVATION_EPOCH_FIELD,
10588 Self::SUI_BALANCE_FIELD,
10589 Self::REWARDS_POOL_FIELD,
10590 Self::POOL_TOKEN_BALANCE_FIELD,
10591 Self::EXCHANGE_RATES_FIELD,
10592 Self::PENDING_STAKE_FIELD,
10593 Self::PENDING_TOTAL_SUI_WITHDRAW_FIELD,
10594 Self::PENDING_POOL_TOKEN_WITHDRAW_FIELD,
10595 Self::EXTRA_FIELDS_FIELD,
10596 ];
10597 }
10598 impl StakingPool {
10599 pub fn path_builder() -> StakingPoolFieldPathBuilder {
10600 StakingPoolFieldPathBuilder::new()
10601 }
10602 }
10603 pub struct StakingPoolFieldPathBuilder {
10604 path: Vec<&'static str>,
10605 }
10606 impl StakingPoolFieldPathBuilder {
10607 #[allow(clippy::new_without_default)]
10608 pub fn new() -> Self {
10609 Self { path: Default::default() }
10610 }
10611 #[doc(hidden)]
10612 pub fn new_with_base(base: Vec<&'static str>) -> Self {
10613 Self { path: base }
10614 }
10615 pub fn finish(self) -> String {
10616 self.path.join(".")
10617 }
10618 pub fn id(mut self) -> String {
10619 self.path.push(StakingPool::ID_FIELD.name);
10620 self.finish()
10621 }
10622 pub fn activation_epoch(mut self) -> String {
10623 self.path.push(StakingPool::ACTIVATION_EPOCH_FIELD.name);
10624 self.finish()
10625 }
10626 pub fn deactivation_epoch(mut self) -> String {
10627 self.path.push(StakingPool::DEACTIVATION_EPOCH_FIELD.name);
10628 self.finish()
10629 }
10630 pub fn sui_balance(mut self) -> String {
10631 self.path.push(StakingPool::SUI_BALANCE_FIELD.name);
10632 self.finish()
10633 }
10634 pub fn rewards_pool(mut self) -> String {
10635 self.path.push(StakingPool::REWARDS_POOL_FIELD.name);
10636 self.finish()
10637 }
10638 pub fn pool_token_balance(mut self) -> String {
10639 self.path.push(StakingPool::POOL_TOKEN_BALANCE_FIELD.name);
10640 self.finish()
10641 }
10642 pub fn exchange_rates(mut self) -> MoveTableFieldPathBuilder {
10643 self.path.push(StakingPool::EXCHANGE_RATES_FIELD.name);
10644 MoveTableFieldPathBuilder::new_with_base(self.path)
10645 }
10646 pub fn pending_stake(mut self) -> String {
10647 self.path.push(StakingPool::PENDING_STAKE_FIELD.name);
10648 self.finish()
10649 }
10650 pub fn pending_total_sui_withdraw(mut self) -> String {
10651 self.path.push(StakingPool::PENDING_TOTAL_SUI_WITHDRAW_FIELD.name);
10652 self.finish()
10653 }
10654 pub fn pending_pool_token_withdraw(mut self) -> String {
10655 self.path.push(StakingPool::PENDING_POOL_TOKEN_WITHDRAW_FIELD.name);
10656 self.finish()
10657 }
10658 pub fn extra_fields(mut self) -> MoveTableFieldPathBuilder {
10659 self.path.push(StakingPool::EXTRA_FIELDS_FIELD.name);
10660 MoveTableFieldPathBuilder::new_with_base(self.path)
10661 }
10662 }
10663 impl Transaction {
10664 pub const BCS_FIELD: &'static MessageField = &MessageField {
10665 name: "bcs",
10666 json_name: "bcs",
10667 number: 1i32,
10668 message_fields: Some(Bcs::FIELDS),
10669 };
10670 pub const DIGEST_FIELD: &'static MessageField = &MessageField {
10671 name: "digest",
10672 json_name: "digest",
10673 number: 2i32,
10674 message_fields: None,
10675 };
10676 pub const VERSION_FIELD: &'static MessageField = &MessageField {
10677 name: "version",
10678 json_name: "version",
10679 number: 3i32,
10680 message_fields: None,
10681 };
10682 pub const KIND_FIELD: &'static MessageField = &MessageField {
10683 name: "kind",
10684 json_name: "kind",
10685 number: 4i32,
10686 message_fields: Some(TransactionKind::FIELDS),
10687 };
10688 pub const SENDER_FIELD: &'static MessageField = &MessageField {
10689 name: "sender",
10690 json_name: "sender",
10691 number: 5i32,
10692 message_fields: None,
10693 };
10694 pub const GAS_PAYMENT_FIELD: &'static MessageField = &MessageField {
10695 name: "gas_payment",
10696 json_name: "gasPayment",
10697 number: 6i32,
10698 message_fields: Some(GasPayment::FIELDS),
10699 };
10700 pub const EXPIRATION_FIELD: &'static MessageField = &MessageField {
10701 name: "expiration",
10702 json_name: "expiration",
10703 number: 7i32,
10704 message_fields: Some(TransactionExpiration::FIELDS),
10705 };
10706 }
10707 impl MessageFields for Transaction {
10708 const FIELDS: &'static [&'static MessageField] = &[
10709 Self::BCS_FIELD,
10710 Self::DIGEST_FIELD,
10711 Self::VERSION_FIELD,
10712 Self::KIND_FIELD,
10713 Self::SENDER_FIELD,
10714 Self::GAS_PAYMENT_FIELD,
10715 Self::EXPIRATION_FIELD,
10716 ];
10717 }
10718 impl Transaction {
10719 pub fn path_builder() -> TransactionFieldPathBuilder {
10720 TransactionFieldPathBuilder::new()
10721 }
10722 }
10723 pub struct TransactionFieldPathBuilder {
10724 path: Vec<&'static str>,
10725 }
10726 impl TransactionFieldPathBuilder {
10727 #[allow(clippy::new_without_default)]
10728 pub fn new() -> Self {
10729 Self { path: Default::default() }
10730 }
10731 #[doc(hidden)]
10732 pub fn new_with_base(base: Vec<&'static str>) -> Self {
10733 Self { path: base }
10734 }
10735 pub fn finish(self) -> String {
10736 self.path.join(".")
10737 }
10738 pub fn bcs(mut self) -> BcsFieldPathBuilder {
10739 self.path.push(Transaction::BCS_FIELD.name);
10740 BcsFieldPathBuilder::new_with_base(self.path)
10741 }
10742 pub fn digest(mut self) -> String {
10743 self.path.push(Transaction::DIGEST_FIELD.name);
10744 self.finish()
10745 }
10746 pub fn version(mut self) -> String {
10747 self.path.push(Transaction::VERSION_FIELD.name);
10748 self.finish()
10749 }
10750 pub fn kind(mut self) -> TransactionKindFieldPathBuilder {
10751 self.path.push(Transaction::KIND_FIELD.name);
10752 TransactionKindFieldPathBuilder::new_with_base(self.path)
10753 }
10754 pub fn sender(mut self) -> String {
10755 self.path.push(Transaction::SENDER_FIELD.name);
10756 self.finish()
10757 }
10758 pub fn gas_payment(mut self) -> GasPaymentFieldPathBuilder {
10759 self.path.push(Transaction::GAS_PAYMENT_FIELD.name);
10760 GasPaymentFieldPathBuilder::new_with_base(self.path)
10761 }
10762 pub fn expiration(mut self) -> TransactionExpirationFieldPathBuilder {
10763 self.path.push(Transaction::EXPIRATION_FIELD.name);
10764 TransactionExpirationFieldPathBuilder::new_with_base(self.path)
10765 }
10766 }
10767 impl GasPayment {
10768 pub const OBJECTS_FIELD: &'static MessageField = &MessageField {
10769 name: "objects",
10770 json_name: "objects",
10771 number: 1i32,
10772 message_fields: Some(ObjectReference::FIELDS),
10773 };
10774 pub const OWNER_FIELD: &'static MessageField = &MessageField {
10775 name: "owner",
10776 json_name: "owner",
10777 number: 2i32,
10778 message_fields: None,
10779 };
10780 pub const PRICE_FIELD: &'static MessageField = &MessageField {
10781 name: "price",
10782 json_name: "price",
10783 number: 3i32,
10784 message_fields: None,
10785 };
10786 pub const BUDGET_FIELD: &'static MessageField = &MessageField {
10787 name: "budget",
10788 json_name: "budget",
10789 number: 4i32,
10790 message_fields: None,
10791 };
10792 }
10793 impl MessageFields for GasPayment {
10794 const FIELDS: &'static [&'static MessageField] = &[
10795 Self::OBJECTS_FIELD,
10796 Self::OWNER_FIELD,
10797 Self::PRICE_FIELD,
10798 Self::BUDGET_FIELD,
10799 ];
10800 }
10801 impl GasPayment {
10802 pub fn path_builder() -> GasPaymentFieldPathBuilder {
10803 GasPaymentFieldPathBuilder::new()
10804 }
10805 }
10806 pub struct GasPaymentFieldPathBuilder {
10807 path: Vec<&'static str>,
10808 }
10809 impl GasPaymentFieldPathBuilder {
10810 #[allow(clippy::new_without_default)]
10811 pub fn new() -> Self {
10812 Self { path: Default::default() }
10813 }
10814 #[doc(hidden)]
10815 pub fn new_with_base(base: Vec<&'static str>) -> Self {
10816 Self { path: base }
10817 }
10818 pub fn finish(self) -> String {
10819 self.path.join(".")
10820 }
10821 pub fn objects(mut self) -> ObjectReferenceFieldPathBuilder {
10822 self.path.push(GasPayment::OBJECTS_FIELD.name);
10823 ObjectReferenceFieldPathBuilder::new_with_base(self.path)
10824 }
10825 pub fn owner(mut self) -> String {
10826 self.path.push(GasPayment::OWNER_FIELD.name);
10827 self.finish()
10828 }
10829 pub fn price(mut self) -> String {
10830 self.path.push(GasPayment::PRICE_FIELD.name);
10831 self.finish()
10832 }
10833 pub fn budget(mut self) -> String {
10834 self.path.push(GasPayment::BUDGET_FIELD.name);
10835 self.finish()
10836 }
10837 }
10838 impl TransactionExpiration {
10839 pub const KIND_FIELD: &'static MessageField = &MessageField {
10840 name: "kind",
10841 json_name: "kind",
10842 number: 1i32,
10843 message_fields: None,
10844 };
10845 pub const EPOCH_FIELD: &'static MessageField = &MessageField {
10846 name: "epoch",
10847 json_name: "epoch",
10848 number: 2i32,
10849 message_fields: None,
10850 };
10851 pub const MIN_EPOCH_FIELD: &'static MessageField = &MessageField {
10852 name: "min_epoch",
10853 json_name: "minEpoch",
10854 number: 3i32,
10855 message_fields: None,
10856 };
10857 pub const MIN_TIMESTAMP_FIELD: &'static MessageField = &MessageField {
10858 name: "min_timestamp",
10859 json_name: "minTimestamp",
10860 number: 4i32,
10861 message_fields: None,
10862 };
10863 pub const MAX_TIMESTAMP_FIELD: &'static MessageField = &MessageField {
10864 name: "max_timestamp",
10865 json_name: "maxTimestamp",
10866 number: 5i32,
10867 message_fields: None,
10868 };
10869 pub const CHAIN_FIELD: &'static MessageField = &MessageField {
10870 name: "chain",
10871 json_name: "chain",
10872 number: 6i32,
10873 message_fields: None,
10874 };
10875 pub const NONCE_FIELD: &'static MessageField = &MessageField {
10876 name: "nonce",
10877 json_name: "nonce",
10878 number: 7i32,
10879 message_fields: None,
10880 };
10881 }
10882 impl MessageFields for TransactionExpiration {
10883 const FIELDS: &'static [&'static MessageField] = &[
10884 Self::KIND_FIELD,
10885 Self::EPOCH_FIELD,
10886 Self::MIN_EPOCH_FIELD,
10887 Self::MIN_TIMESTAMP_FIELD,
10888 Self::MAX_TIMESTAMP_FIELD,
10889 Self::CHAIN_FIELD,
10890 Self::NONCE_FIELD,
10891 ];
10892 }
10893 impl TransactionExpiration {
10894 pub fn path_builder() -> TransactionExpirationFieldPathBuilder {
10895 TransactionExpirationFieldPathBuilder::new()
10896 }
10897 }
10898 pub struct TransactionExpirationFieldPathBuilder {
10899 path: Vec<&'static str>,
10900 }
10901 impl TransactionExpirationFieldPathBuilder {
10902 #[allow(clippy::new_without_default)]
10903 pub fn new() -> Self {
10904 Self { path: Default::default() }
10905 }
10906 #[doc(hidden)]
10907 pub fn new_with_base(base: Vec<&'static str>) -> Self {
10908 Self { path: base }
10909 }
10910 pub fn finish(self) -> String {
10911 self.path.join(".")
10912 }
10913 pub fn kind(mut self) -> String {
10914 self.path.push(TransactionExpiration::KIND_FIELD.name);
10915 self.finish()
10916 }
10917 pub fn epoch(mut self) -> String {
10918 self.path.push(TransactionExpiration::EPOCH_FIELD.name);
10919 self.finish()
10920 }
10921 pub fn min_epoch(mut self) -> String {
10922 self.path.push(TransactionExpiration::MIN_EPOCH_FIELD.name);
10923 self.finish()
10924 }
10925 pub fn min_timestamp(mut self) -> String {
10926 self.path.push(TransactionExpiration::MIN_TIMESTAMP_FIELD.name);
10927 self.finish()
10928 }
10929 pub fn max_timestamp(mut self) -> String {
10930 self.path.push(TransactionExpiration::MAX_TIMESTAMP_FIELD.name);
10931 self.finish()
10932 }
10933 pub fn chain(mut self) -> String {
10934 self.path.push(TransactionExpiration::CHAIN_FIELD.name);
10935 self.finish()
10936 }
10937 pub fn nonce(mut self) -> String {
10938 self.path.push(TransactionExpiration::NONCE_FIELD.name);
10939 self.finish()
10940 }
10941 }
10942 impl TransactionKind {
10943 pub const KIND_FIELD: &'static MessageField = &MessageField {
10944 name: "kind",
10945 json_name: "kind",
10946 number: 1i32,
10947 message_fields: None,
10948 };
10949 pub const PROGRAMMABLE_TRANSACTION_FIELD: &'static MessageField = &MessageField {
10950 name: "programmable_transaction",
10951 json_name: "programmableTransaction",
10952 number: 2i32,
10953 message_fields: Some(ProgrammableTransaction::FIELDS),
10954 };
10955 pub const CHANGE_EPOCH_FIELD: &'static MessageField = &MessageField {
10956 name: "change_epoch",
10957 json_name: "changeEpoch",
10958 number: 3i32,
10959 message_fields: Some(ChangeEpoch::FIELDS),
10960 };
10961 pub const GENESIS_FIELD: &'static MessageField = &MessageField {
10962 name: "genesis",
10963 json_name: "genesis",
10964 number: 4i32,
10965 message_fields: Some(GenesisTransaction::FIELDS),
10966 };
10967 pub const CONSENSUS_COMMIT_PROLOGUE_FIELD: &'static MessageField = &MessageField {
10968 name: "consensus_commit_prologue",
10969 json_name: "consensusCommitPrologue",
10970 number: 5i32,
10971 message_fields: Some(ConsensusCommitPrologue::FIELDS),
10972 };
10973 pub const AUTHENTICATOR_STATE_UPDATE_FIELD: &'static MessageField = &MessageField {
10974 name: "authenticator_state_update",
10975 json_name: "authenticatorStateUpdate",
10976 number: 6i32,
10977 message_fields: Some(AuthenticatorStateUpdate::FIELDS),
10978 };
10979 pub const END_OF_EPOCH_FIELD: &'static MessageField = &MessageField {
10980 name: "end_of_epoch",
10981 json_name: "endOfEpoch",
10982 number: 7i32,
10983 message_fields: Some(EndOfEpochTransaction::FIELDS),
10984 };
10985 pub const RANDOMNESS_STATE_UPDATE_FIELD: &'static MessageField = &MessageField {
10986 name: "randomness_state_update",
10987 json_name: "randomnessStateUpdate",
10988 number: 8i32,
10989 message_fields: Some(RandomnessStateUpdate::FIELDS),
10990 };
10991 }
10992 impl MessageFields for TransactionKind {
10993 const FIELDS: &'static [&'static MessageField] = &[
10994 Self::KIND_FIELD,
10995 Self::PROGRAMMABLE_TRANSACTION_FIELD,
10996 Self::CHANGE_EPOCH_FIELD,
10997 Self::GENESIS_FIELD,
10998 Self::CONSENSUS_COMMIT_PROLOGUE_FIELD,
10999 Self::AUTHENTICATOR_STATE_UPDATE_FIELD,
11000 Self::END_OF_EPOCH_FIELD,
11001 Self::RANDOMNESS_STATE_UPDATE_FIELD,
11002 ];
11003 }
11004 impl TransactionKind {
11005 pub fn path_builder() -> TransactionKindFieldPathBuilder {
11006 TransactionKindFieldPathBuilder::new()
11007 }
11008 }
11009 pub struct TransactionKindFieldPathBuilder {
11010 path: Vec<&'static str>,
11011 }
11012 impl TransactionKindFieldPathBuilder {
11013 #[allow(clippy::new_without_default)]
11014 pub fn new() -> Self {
11015 Self { path: Default::default() }
11016 }
11017 #[doc(hidden)]
11018 pub fn new_with_base(base: Vec<&'static str>) -> Self {
11019 Self { path: base }
11020 }
11021 pub fn finish(self) -> String {
11022 self.path.join(".")
11023 }
11024 pub fn kind(mut self) -> String {
11025 self.path.push(TransactionKind::KIND_FIELD.name);
11026 self.finish()
11027 }
11028 pub fn programmable_transaction(
11029 mut self,
11030 ) -> ProgrammableTransactionFieldPathBuilder {
11031 self.path.push(TransactionKind::PROGRAMMABLE_TRANSACTION_FIELD.name);
11032 ProgrammableTransactionFieldPathBuilder::new_with_base(self.path)
11033 }
11034 pub fn change_epoch(mut self) -> ChangeEpochFieldPathBuilder {
11035 self.path.push(TransactionKind::CHANGE_EPOCH_FIELD.name);
11036 ChangeEpochFieldPathBuilder::new_with_base(self.path)
11037 }
11038 pub fn genesis(mut self) -> GenesisTransactionFieldPathBuilder {
11039 self.path.push(TransactionKind::GENESIS_FIELD.name);
11040 GenesisTransactionFieldPathBuilder::new_with_base(self.path)
11041 }
11042 pub fn consensus_commit_prologue(
11043 mut self,
11044 ) -> ConsensusCommitPrologueFieldPathBuilder {
11045 self.path.push(TransactionKind::CONSENSUS_COMMIT_PROLOGUE_FIELD.name);
11046 ConsensusCommitPrologueFieldPathBuilder::new_with_base(self.path)
11047 }
11048 pub fn authenticator_state_update(
11049 mut self,
11050 ) -> AuthenticatorStateUpdateFieldPathBuilder {
11051 self.path.push(TransactionKind::AUTHENTICATOR_STATE_UPDATE_FIELD.name);
11052 AuthenticatorStateUpdateFieldPathBuilder::new_with_base(self.path)
11053 }
11054 pub fn end_of_epoch(mut self) -> EndOfEpochTransactionFieldPathBuilder {
11055 self.path.push(TransactionKind::END_OF_EPOCH_FIELD.name);
11056 EndOfEpochTransactionFieldPathBuilder::new_with_base(self.path)
11057 }
11058 pub fn randomness_state_update(
11059 mut self,
11060 ) -> RandomnessStateUpdateFieldPathBuilder {
11061 self.path.push(TransactionKind::RANDOMNESS_STATE_UPDATE_FIELD.name);
11062 RandomnessStateUpdateFieldPathBuilder::new_with_base(self.path)
11063 }
11064 }
11065 impl ProgrammableTransaction {
11066 pub const INPUTS_FIELD: &'static MessageField = &MessageField {
11067 name: "inputs",
11068 json_name: "inputs",
11069 number: 1i32,
11070 message_fields: Some(Input::FIELDS),
11071 };
11072 pub const COMMANDS_FIELD: &'static MessageField = &MessageField {
11073 name: "commands",
11074 json_name: "commands",
11075 number: 2i32,
11076 message_fields: Some(Command::FIELDS),
11077 };
11078 }
11079 impl MessageFields for ProgrammableTransaction {
11080 const FIELDS: &'static [&'static MessageField] = &[
11081 Self::INPUTS_FIELD,
11082 Self::COMMANDS_FIELD,
11083 ];
11084 }
11085 impl ProgrammableTransaction {
11086 pub fn path_builder() -> ProgrammableTransactionFieldPathBuilder {
11087 ProgrammableTransactionFieldPathBuilder::new()
11088 }
11089 }
11090 pub struct ProgrammableTransactionFieldPathBuilder {
11091 path: Vec<&'static str>,
11092 }
11093 impl ProgrammableTransactionFieldPathBuilder {
11094 #[allow(clippy::new_without_default)]
11095 pub fn new() -> Self {
11096 Self { path: Default::default() }
11097 }
11098 #[doc(hidden)]
11099 pub fn new_with_base(base: Vec<&'static str>) -> Self {
11100 Self { path: base }
11101 }
11102 pub fn finish(self) -> String {
11103 self.path.join(".")
11104 }
11105 pub fn inputs(mut self) -> InputFieldPathBuilder {
11106 self.path.push(ProgrammableTransaction::INPUTS_FIELD.name);
11107 InputFieldPathBuilder::new_with_base(self.path)
11108 }
11109 pub fn commands(mut self) -> CommandFieldPathBuilder {
11110 self.path.push(ProgrammableTransaction::COMMANDS_FIELD.name);
11111 CommandFieldPathBuilder::new_with_base(self.path)
11112 }
11113 }
11114 impl Command {
11115 pub const MOVE_CALL_FIELD: &'static MessageField = &MessageField {
11116 name: "move_call",
11117 json_name: "moveCall",
11118 number: 1i32,
11119 message_fields: Some(MoveCall::FIELDS),
11120 };
11121 pub const TRANSFER_OBJECTS_FIELD: &'static MessageField = &MessageField {
11122 name: "transfer_objects",
11123 json_name: "transferObjects",
11124 number: 2i32,
11125 message_fields: Some(TransferObjects::FIELDS),
11126 };
11127 pub const SPLIT_COINS_FIELD: &'static MessageField = &MessageField {
11128 name: "split_coins",
11129 json_name: "splitCoins",
11130 number: 3i32,
11131 message_fields: Some(SplitCoins::FIELDS),
11132 };
11133 pub const MERGE_COINS_FIELD: &'static MessageField = &MessageField {
11134 name: "merge_coins",
11135 json_name: "mergeCoins",
11136 number: 4i32,
11137 message_fields: Some(MergeCoins::FIELDS),
11138 };
11139 pub const PUBLISH_FIELD: &'static MessageField = &MessageField {
11140 name: "publish",
11141 json_name: "publish",
11142 number: 5i32,
11143 message_fields: Some(Publish::FIELDS),
11144 };
11145 pub const MAKE_MOVE_VECTOR_FIELD: &'static MessageField = &MessageField {
11146 name: "make_move_vector",
11147 json_name: "makeMoveVector",
11148 number: 6i32,
11149 message_fields: Some(MakeMoveVector::FIELDS),
11150 };
11151 pub const UPGRADE_FIELD: &'static MessageField = &MessageField {
11152 name: "upgrade",
11153 json_name: "upgrade",
11154 number: 7i32,
11155 message_fields: Some(Upgrade::FIELDS),
11156 };
11157 }
11158 impl MessageFields for Command {
11159 const FIELDS: &'static [&'static MessageField] = &[
11160 Self::MOVE_CALL_FIELD,
11161 Self::TRANSFER_OBJECTS_FIELD,
11162 Self::SPLIT_COINS_FIELD,
11163 Self::MERGE_COINS_FIELD,
11164 Self::PUBLISH_FIELD,
11165 Self::MAKE_MOVE_VECTOR_FIELD,
11166 Self::UPGRADE_FIELD,
11167 ];
11168 }
11169 impl Command {
11170 pub fn path_builder() -> CommandFieldPathBuilder {
11171 CommandFieldPathBuilder::new()
11172 }
11173 }
11174 pub struct CommandFieldPathBuilder {
11175 path: Vec<&'static str>,
11176 }
11177 impl CommandFieldPathBuilder {
11178 #[allow(clippy::new_without_default)]
11179 pub fn new() -> Self {
11180 Self { path: Default::default() }
11181 }
11182 #[doc(hidden)]
11183 pub fn new_with_base(base: Vec<&'static str>) -> Self {
11184 Self { path: base }
11185 }
11186 pub fn finish(self) -> String {
11187 self.path.join(".")
11188 }
11189 pub fn move_call(mut self) -> MoveCallFieldPathBuilder {
11190 self.path.push(Command::MOVE_CALL_FIELD.name);
11191 MoveCallFieldPathBuilder::new_with_base(self.path)
11192 }
11193 pub fn transfer_objects(mut self) -> TransferObjectsFieldPathBuilder {
11194 self.path.push(Command::TRANSFER_OBJECTS_FIELD.name);
11195 TransferObjectsFieldPathBuilder::new_with_base(self.path)
11196 }
11197 pub fn split_coins(mut self) -> SplitCoinsFieldPathBuilder {
11198 self.path.push(Command::SPLIT_COINS_FIELD.name);
11199 SplitCoinsFieldPathBuilder::new_with_base(self.path)
11200 }
11201 pub fn merge_coins(mut self) -> MergeCoinsFieldPathBuilder {
11202 self.path.push(Command::MERGE_COINS_FIELD.name);
11203 MergeCoinsFieldPathBuilder::new_with_base(self.path)
11204 }
11205 pub fn publish(mut self) -> PublishFieldPathBuilder {
11206 self.path.push(Command::PUBLISH_FIELD.name);
11207 PublishFieldPathBuilder::new_with_base(self.path)
11208 }
11209 pub fn make_move_vector(mut self) -> MakeMoveVectorFieldPathBuilder {
11210 self.path.push(Command::MAKE_MOVE_VECTOR_FIELD.name);
11211 MakeMoveVectorFieldPathBuilder::new_with_base(self.path)
11212 }
11213 pub fn upgrade(mut self) -> UpgradeFieldPathBuilder {
11214 self.path.push(Command::UPGRADE_FIELD.name);
11215 UpgradeFieldPathBuilder::new_with_base(self.path)
11216 }
11217 }
11218 impl MoveCall {
11219 pub const PACKAGE_FIELD: &'static MessageField = &MessageField {
11220 name: "package",
11221 json_name: "package",
11222 number: 1i32,
11223 message_fields: None,
11224 };
11225 pub const MODULE_FIELD: &'static MessageField = &MessageField {
11226 name: "module",
11227 json_name: "module",
11228 number: 2i32,
11229 message_fields: None,
11230 };
11231 pub const FUNCTION_FIELD: &'static MessageField = &MessageField {
11232 name: "function",
11233 json_name: "function",
11234 number: 3i32,
11235 message_fields: None,
11236 };
11237 pub const TYPE_ARGUMENTS_FIELD: &'static MessageField = &MessageField {
11238 name: "type_arguments",
11239 json_name: "typeArguments",
11240 number: 4i32,
11241 message_fields: None,
11242 };
11243 pub const ARGUMENTS_FIELD: &'static MessageField = &MessageField {
11244 name: "arguments",
11245 json_name: "arguments",
11246 number: 5i32,
11247 message_fields: Some(Argument::FIELDS),
11248 };
11249 }
11250 impl MessageFields for MoveCall {
11251 const FIELDS: &'static [&'static MessageField] = &[
11252 Self::PACKAGE_FIELD,
11253 Self::MODULE_FIELD,
11254 Self::FUNCTION_FIELD,
11255 Self::TYPE_ARGUMENTS_FIELD,
11256 Self::ARGUMENTS_FIELD,
11257 ];
11258 }
11259 impl MoveCall {
11260 pub fn path_builder() -> MoveCallFieldPathBuilder {
11261 MoveCallFieldPathBuilder::new()
11262 }
11263 }
11264 pub struct MoveCallFieldPathBuilder {
11265 path: Vec<&'static str>,
11266 }
11267 impl MoveCallFieldPathBuilder {
11268 #[allow(clippy::new_without_default)]
11269 pub fn new() -> Self {
11270 Self { path: Default::default() }
11271 }
11272 #[doc(hidden)]
11273 pub fn new_with_base(base: Vec<&'static str>) -> Self {
11274 Self { path: base }
11275 }
11276 pub fn finish(self) -> String {
11277 self.path.join(".")
11278 }
11279 pub fn package(mut self) -> String {
11280 self.path.push(MoveCall::PACKAGE_FIELD.name);
11281 self.finish()
11282 }
11283 pub fn module(mut self) -> String {
11284 self.path.push(MoveCall::MODULE_FIELD.name);
11285 self.finish()
11286 }
11287 pub fn function(mut self) -> String {
11288 self.path.push(MoveCall::FUNCTION_FIELD.name);
11289 self.finish()
11290 }
11291 pub fn type_arguments(mut self) -> String {
11292 self.path.push(MoveCall::TYPE_ARGUMENTS_FIELD.name);
11293 self.finish()
11294 }
11295 pub fn arguments(mut self) -> ArgumentFieldPathBuilder {
11296 self.path.push(MoveCall::ARGUMENTS_FIELD.name);
11297 ArgumentFieldPathBuilder::new_with_base(self.path)
11298 }
11299 }
11300 impl TransferObjects {
11301 pub const OBJECTS_FIELD: &'static MessageField = &MessageField {
11302 name: "objects",
11303 json_name: "objects",
11304 number: 1i32,
11305 message_fields: Some(Argument::FIELDS),
11306 };
11307 pub const ADDRESS_FIELD: &'static MessageField = &MessageField {
11308 name: "address",
11309 json_name: "address",
11310 number: 2i32,
11311 message_fields: Some(Argument::FIELDS),
11312 };
11313 }
11314 impl MessageFields for TransferObjects {
11315 const FIELDS: &'static [&'static MessageField] = &[
11316 Self::OBJECTS_FIELD,
11317 Self::ADDRESS_FIELD,
11318 ];
11319 }
11320 impl TransferObjects {
11321 pub fn path_builder() -> TransferObjectsFieldPathBuilder {
11322 TransferObjectsFieldPathBuilder::new()
11323 }
11324 }
11325 pub struct TransferObjectsFieldPathBuilder {
11326 path: Vec<&'static str>,
11327 }
11328 impl TransferObjectsFieldPathBuilder {
11329 #[allow(clippy::new_without_default)]
11330 pub fn new() -> Self {
11331 Self { path: Default::default() }
11332 }
11333 #[doc(hidden)]
11334 pub fn new_with_base(base: Vec<&'static str>) -> Self {
11335 Self { path: base }
11336 }
11337 pub fn finish(self) -> String {
11338 self.path.join(".")
11339 }
11340 pub fn objects(mut self) -> ArgumentFieldPathBuilder {
11341 self.path.push(TransferObjects::OBJECTS_FIELD.name);
11342 ArgumentFieldPathBuilder::new_with_base(self.path)
11343 }
11344 pub fn address(mut self) -> ArgumentFieldPathBuilder {
11345 self.path.push(TransferObjects::ADDRESS_FIELD.name);
11346 ArgumentFieldPathBuilder::new_with_base(self.path)
11347 }
11348 }
11349 impl SplitCoins {
11350 pub const COIN_FIELD: &'static MessageField = &MessageField {
11351 name: "coin",
11352 json_name: "coin",
11353 number: 1i32,
11354 message_fields: Some(Argument::FIELDS),
11355 };
11356 pub const AMOUNTS_FIELD: &'static MessageField = &MessageField {
11357 name: "amounts",
11358 json_name: "amounts",
11359 number: 2i32,
11360 message_fields: Some(Argument::FIELDS),
11361 };
11362 }
11363 impl MessageFields for SplitCoins {
11364 const FIELDS: &'static [&'static MessageField] = &[
11365 Self::COIN_FIELD,
11366 Self::AMOUNTS_FIELD,
11367 ];
11368 }
11369 impl SplitCoins {
11370 pub fn path_builder() -> SplitCoinsFieldPathBuilder {
11371 SplitCoinsFieldPathBuilder::new()
11372 }
11373 }
11374 pub struct SplitCoinsFieldPathBuilder {
11375 path: Vec<&'static str>,
11376 }
11377 impl SplitCoinsFieldPathBuilder {
11378 #[allow(clippy::new_without_default)]
11379 pub fn new() -> Self {
11380 Self { path: Default::default() }
11381 }
11382 #[doc(hidden)]
11383 pub fn new_with_base(base: Vec<&'static str>) -> Self {
11384 Self { path: base }
11385 }
11386 pub fn finish(self) -> String {
11387 self.path.join(".")
11388 }
11389 pub fn coin(mut self) -> ArgumentFieldPathBuilder {
11390 self.path.push(SplitCoins::COIN_FIELD.name);
11391 ArgumentFieldPathBuilder::new_with_base(self.path)
11392 }
11393 pub fn amounts(mut self) -> ArgumentFieldPathBuilder {
11394 self.path.push(SplitCoins::AMOUNTS_FIELD.name);
11395 ArgumentFieldPathBuilder::new_with_base(self.path)
11396 }
11397 }
11398 impl MergeCoins {
11399 pub const COIN_FIELD: &'static MessageField = &MessageField {
11400 name: "coin",
11401 json_name: "coin",
11402 number: 1i32,
11403 message_fields: Some(Argument::FIELDS),
11404 };
11405 pub const COINS_TO_MERGE_FIELD: &'static MessageField = &MessageField {
11406 name: "coins_to_merge",
11407 json_name: "coinsToMerge",
11408 number: 2i32,
11409 message_fields: Some(Argument::FIELDS),
11410 };
11411 }
11412 impl MessageFields for MergeCoins {
11413 const FIELDS: &'static [&'static MessageField] = &[
11414 Self::COIN_FIELD,
11415 Self::COINS_TO_MERGE_FIELD,
11416 ];
11417 }
11418 impl MergeCoins {
11419 pub fn path_builder() -> MergeCoinsFieldPathBuilder {
11420 MergeCoinsFieldPathBuilder::new()
11421 }
11422 }
11423 pub struct MergeCoinsFieldPathBuilder {
11424 path: Vec<&'static str>,
11425 }
11426 impl MergeCoinsFieldPathBuilder {
11427 #[allow(clippy::new_without_default)]
11428 pub fn new() -> Self {
11429 Self { path: Default::default() }
11430 }
11431 #[doc(hidden)]
11432 pub fn new_with_base(base: Vec<&'static str>) -> Self {
11433 Self { path: base }
11434 }
11435 pub fn finish(self) -> String {
11436 self.path.join(".")
11437 }
11438 pub fn coin(mut self) -> ArgumentFieldPathBuilder {
11439 self.path.push(MergeCoins::COIN_FIELD.name);
11440 ArgumentFieldPathBuilder::new_with_base(self.path)
11441 }
11442 pub fn coins_to_merge(mut self) -> ArgumentFieldPathBuilder {
11443 self.path.push(MergeCoins::COINS_TO_MERGE_FIELD.name);
11444 ArgumentFieldPathBuilder::new_with_base(self.path)
11445 }
11446 }
11447 impl Publish {
11448 pub const MODULES_FIELD: &'static MessageField = &MessageField {
11449 name: "modules",
11450 json_name: "modules",
11451 number: 1i32,
11452 message_fields: None,
11453 };
11454 pub const DEPENDENCIES_FIELD: &'static MessageField = &MessageField {
11455 name: "dependencies",
11456 json_name: "dependencies",
11457 number: 2i32,
11458 message_fields: None,
11459 };
11460 }
11461 impl MessageFields for Publish {
11462 const FIELDS: &'static [&'static MessageField] = &[
11463 Self::MODULES_FIELD,
11464 Self::DEPENDENCIES_FIELD,
11465 ];
11466 }
11467 impl Publish {
11468 pub fn path_builder() -> PublishFieldPathBuilder {
11469 PublishFieldPathBuilder::new()
11470 }
11471 }
11472 pub struct PublishFieldPathBuilder {
11473 path: Vec<&'static str>,
11474 }
11475 impl PublishFieldPathBuilder {
11476 #[allow(clippy::new_without_default)]
11477 pub fn new() -> Self {
11478 Self { path: Default::default() }
11479 }
11480 #[doc(hidden)]
11481 pub fn new_with_base(base: Vec<&'static str>) -> Self {
11482 Self { path: base }
11483 }
11484 pub fn finish(self) -> String {
11485 self.path.join(".")
11486 }
11487 pub fn modules(mut self) -> String {
11488 self.path.push(Publish::MODULES_FIELD.name);
11489 self.finish()
11490 }
11491 pub fn dependencies(mut self) -> String {
11492 self.path.push(Publish::DEPENDENCIES_FIELD.name);
11493 self.finish()
11494 }
11495 }
11496 impl MakeMoveVector {
11497 pub const ELEMENT_TYPE_FIELD: &'static MessageField = &MessageField {
11498 name: "element_type",
11499 json_name: "elementType",
11500 number: 1i32,
11501 message_fields: None,
11502 };
11503 pub const ELEMENTS_FIELD: &'static MessageField = &MessageField {
11504 name: "elements",
11505 json_name: "elements",
11506 number: 2i32,
11507 message_fields: Some(Argument::FIELDS),
11508 };
11509 }
11510 impl MessageFields for MakeMoveVector {
11511 const FIELDS: &'static [&'static MessageField] = &[
11512 Self::ELEMENT_TYPE_FIELD,
11513 Self::ELEMENTS_FIELD,
11514 ];
11515 }
11516 impl MakeMoveVector {
11517 pub fn path_builder() -> MakeMoveVectorFieldPathBuilder {
11518 MakeMoveVectorFieldPathBuilder::new()
11519 }
11520 }
11521 pub struct MakeMoveVectorFieldPathBuilder {
11522 path: Vec<&'static str>,
11523 }
11524 impl MakeMoveVectorFieldPathBuilder {
11525 #[allow(clippy::new_without_default)]
11526 pub fn new() -> Self {
11527 Self { path: Default::default() }
11528 }
11529 #[doc(hidden)]
11530 pub fn new_with_base(base: Vec<&'static str>) -> Self {
11531 Self { path: base }
11532 }
11533 pub fn finish(self) -> String {
11534 self.path.join(".")
11535 }
11536 pub fn element_type(mut self) -> String {
11537 self.path.push(MakeMoveVector::ELEMENT_TYPE_FIELD.name);
11538 self.finish()
11539 }
11540 pub fn elements(mut self) -> ArgumentFieldPathBuilder {
11541 self.path.push(MakeMoveVector::ELEMENTS_FIELD.name);
11542 ArgumentFieldPathBuilder::new_with_base(self.path)
11543 }
11544 }
11545 impl Upgrade {
11546 pub const MODULES_FIELD: &'static MessageField = &MessageField {
11547 name: "modules",
11548 json_name: "modules",
11549 number: 1i32,
11550 message_fields: None,
11551 };
11552 pub const DEPENDENCIES_FIELD: &'static MessageField = &MessageField {
11553 name: "dependencies",
11554 json_name: "dependencies",
11555 number: 2i32,
11556 message_fields: None,
11557 };
11558 pub const PACKAGE_FIELD: &'static MessageField = &MessageField {
11559 name: "package",
11560 json_name: "package",
11561 number: 3i32,
11562 message_fields: None,
11563 };
11564 pub const TICKET_FIELD: &'static MessageField = &MessageField {
11565 name: "ticket",
11566 json_name: "ticket",
11567 number: 4i32,
11568 message_fields: Some(Argument::FIELDS),
11569 };
11570 }
11571 impl MessageFields for Upgrade {
11572 const FIELDS: &'static [&'static MessageField] = &[
11573 Self::MODULES_FIELD,
11574 Self::DEPENDENCIES_FIELD,
11575 Self::PACKAGE_FIELD,
11576 Self::TICKET_FIELD,
11577 ];
11578 }
11579 impl Upgrade {
11580 pub fn path_builder() -> UpgradeFieldPathBuilder {
11581 UpgradeFieldPathBuilder::new()
11582 }
11583 }
11584 pub struct UpgradeFieldPathBuilder {
11585 path: Vec<&'static str>,
11586 }
11587 impl UpgradeFieldPathBuilder {
11588 #[allow(clippy::new_without_default)]
11589 pub fn new() -> Self {
11590 Self { path: Default::default() }
11591 }
11592 #[doc(hidden)]
11593 pub fn new_with_base(base: Vec<&'static str>) -> Self {
11594 Self { path: base }
11595 }
11596 pub fn finish(self) -> String {
11597 self.path.join(".")
11598 }
11599 pub fn modules(mut self) -> String {
11600 self.path.push(Upgrade::MODULES_FIELD.name);
11601 self.finish()
11602 }
11603 pub fn dependencies(mut self) -> String {
11604 self.path.push(Upgrade::DEPENDENCIES_FIELD.name);
11605 self.finish()
11606 }
11607 pub fn package(mut self) -> String {
11608 self.path.push(Upgrade::PACKAGE_FIELD.name);
11609 self.finish()
11610 }
11611 pub fn ticket(mut self) -> ArgumentFieldPathBuilder {
11612 self.path.push(Upgrade::TICKET_FIELD.name);
11613 ArgumentFieldPathBuilder::new_with_base(self.path)
11614 }
11615 }
11616 impl RandomnessStateUpdate {
11617 pub const EPOCH_FIELD: &'static MessageField = &MessageField {
11618 name: "epoch",
11619 json_name: "epoch",
11620 number: 1i32,
11621 message_fields: None,
11622 };
11623 pub const RANDOMNESS_ROUND_FIELD: &'static MessageField = &MessageField {
11624 name: "randomness_round",
11625 json_name: "randomnessRound",
11626 number: 2i32,
11627 message_fields: None,
11628 };
11629 pub const RANDOM_BYTES_FIELD: &'static MessageField = &MessageField {
11630 name: "random_bytes",
11631 json_name: "randomBytes",
11632 number: 3i32,
11633 message_fields: None,
11634 };
11635 pub const RANDOMNESS_OBJECT_INITIAL_SHARED_VERSION_FIELD: &'static MessageField = &MessageField {
11636 name: "randomness_object_initial_shared_version",
11637 json_name: "randomnessObjectInitialSharedVersion",
11638 number: 4i32,
11639 message_fields: None,
11640 };
11641 }
11642 impl MessageFields for RandomnessStateUpdate {
11643 const FIELDS: &'static [&'static MessageField] = &[
11644 Self::EPOCH_FIELD,
11645 Self::RANDOMNESS_ROUND_FIELD,
11646 Self::RANDOM_BYTES_FIELD,
11647 Self::RANDOMNESS_OBJECT_INITIAL_SHARED_VERSION_FIELD,
11648 ];
11649 }
11650 impl RandomnessStateUpdate {
11651 pub fn path_builder() -> RandomnessStateUpdateFieldPathBuilder {
11652 RandomnessStateUpdateFieldPathBuilder::new()
11653 }
11654 }
11655 pub struct RandomnessStateUpdateFieldPathBuilder {
11656 path: Vec<&'static str>,
11657 }
11658 impl RandomnessStateUpdateFieldPathBuilder {
11659 #[allow(clippy::new_without_default)]
11660 pub fn new() -> Self {
11661 Self { path: Default::default() }
11662 }
11663 #[doc(hidden)]
11664 pub fn new_with_base(base: Vec<&'static str>) -> Self {
11665 Self { path: base }
11666 }
11667 pub fn finish(self) -> String {
11668 self.path.join(".")
11669 }
11670 pub fn epoch(mut self) -> String {
11671 self.path.push(RandomnessStateUpdate::EPOCH_FIELD.name);
11672 self.finish()
11673 }
11674 pub fn randomness_round(mut self) -> String {
11675 self.path.push(RandomnessStateUpdate::RANDOMNESS_ROUND_FIELD.name);
11676 self.finish()
11677 }
11678 pub fn random_bytes(mut self) -> String {
11679 self.path.push(RandomnessStateUpdate::RANDOM_BYTES_FIELD.name);
11680 self.finish()
11681 }
11682 pub fn randomness_object_initial_shared_version(mut self) -> String {
11683 self.path
11684 .push(
11685 RandomnessStateUpdate::RANDOMNESS_OBJECT_INITIAL_SHARED_VERSION_FIELD
11686 .name,
11687 );
11688 self.finish()
11689 }
11690 }
11691 impl ChangeEpoch {
11692 pub const EPOCH_FIELD: &'static MessageField = &MessageField {
11693 name: "epoch",
11694 json_name: "epoch",
11695 number: 1i32,
11696 message_fields: None,
11697 };
11698 pub const PROTOCOL_VERSION_FIELD: &'static MessageField = &MessageField {
11699 name: "protocol_version",
11700 json_name: "protocolVersion",
11701 number: 2i32,
11702 message_fields: None,
11703 };
11704 pub const STORAGE_CHARGE_FIELD: &'static MessageField = &MessageField {
11705 name: "storage_charge",
11706 json_name: "storageCharge",
11707 number: 3i32,
11708 message_fields: None,
11709 };
11710 pub const COMPUTATION_CHARGE_FIELD: &'static MessageField = &MessageField {
11711 name: "computation_charge",
11712 json_name: "computationCharge",
11713 number: 4i32,
11714 message_fields: None,
11715 };
11716 pub const STORAGE_REBATE_FIELD: &'static MessageField = &MessageField {
11717 name: "storage_rebate",
11718 json_name: "storageRebate",
11719 number: 5i32,
11720 message_fields: None,
11721 };
11722 pub const NON_REFUNDABLE_STORAGE_FEE_FIELD: &'static MessageField = &MessageField {
11723 name: "non_refundable_storage_fee",
11724 json_name: "nonRefundableStorageFee",
11725 number: 6i32,
11726 message_fields: None,
11727 };
11728 pub const EPOCH_START_TIMESTAMP_FIELD: &'static MessageField = &MessageField {
11729 name: "epoch_start_timestamp",
11730 json_name: "epochStartTimestamp",
11731 number: 7i32,
11732 message_fields: None,
11733 };
11734 pub const SYSTEM_PACKAGES_FIELD: &'static MessageField = &MessageField {
11735 name: "system_packages",
11736 json_name: "systemPackages",
11737 number: 8i32,
11738 message_fields: Some(SystemPackage::FIELDS),
11739 };
11740 }
11741 impl MessageFields for ChangeEpoch {
11742 const FIELDS: &'static [&'static MessageField] = &[
11743 Self::EPOCH_FIELD,
11744 Self::PROTOCOL_VERSION_FIELD,
11745 Self::STORAGE_CHARGE_FIELD,
11746 Self::COMPUTATION_CHARGE_FIELD,
11747 Self::STORAGE_REBATE_FIELD,
11748 Self::NON_REFUNDABLE_STORAGE_FEE_FIELD,
11749 Self::EPOCH_START_TIMESTAMP_FIELD,
11750 Self::SYSTEM_PACKAGES_FIELD,
11751 ];
11752 }
11753 impl ChangeEpoch {
11754 pub fn path_builder() -> ChangeEpochFieldPathBuilder {
11755 ChangeEpochFieldPathBuilder::new()
11756 }
11757 }
11758 pub struct ChangeEpochFieldPathBuilder {
11759 path: Vec<&'static str>,
11760 }
11761 impl ChangeEpochFieldPathBuilder {
11762 #[allow(clippy::new_without_default)]
11763 pub fn new() -> Self {
11764 Self { path: Default::default() }
11765 }
11766 #[doc(hidden)]
11767 pub fn new_with_base(base: Vec<&'static str>) -> Self {
11768 Self { path: base }
11769 }
11770 pub fn finish(self) -> String {
11771 self.path.join(".")
11772 }
11773 pub fn epoch(mut self) -> String {
11774 self.path.push(ChangeEpoch::EPOCH_FIELD.name);
11775 self.finish()
11776 }
11777 pub fn protocol_version(mut self) -> String {
11778 self.path.push(ChangeEpoch::PROTOCOL_VERSION_FIELD.name);
11779 self.finish()
11780 }
11781 pub fn storage_charge(mut self) -> String {
11782 self.path.push(ChangeEpoch::STORAGE_CHARGE_FIELD.name);
11783 self.finish()
11784 }
11785 pub fn computation_charge(mut self) -> String {
11786 self.path.push(ChangeEpoch::COMPUTATION_CHARGE_FIELD.name);
11787 self.finish()
11788 }
11789 pub fn storage_rebate(mut self) -> String {
11790 self.path.push(ChangeEpoch::STORAGE_REBATE_FIELD.name);
11791 self.finish()
11792 }
11793 pub fn non_refundable_storage_fee(mut self) -> String {
11794 self.path.push(ChangeEpoch::NON_REFUNDABLE_STORAGE_FEE_FIELD.name);
11795 self.finish()
11796 }
11797 pub fn epoch_start_timestamp(mut self) -> String {
11798 self.path.push(ChangeEpoch::EPOCH_START_TIMESTAMP_FIELD.name);
11799 self.finish()
11800 }
11801 pub fn system_packages(mut self) -> SystemPackageFieldPathBuilder {
11802 self.path.push(ChangeEpoch::SYSTEM_PACKAGES_FIELD.name);
11803 SystemPackageFieldPathBuilder::new_with_base(self.path)
11804 }
11805 }
11806 impl SystemPackage {
11807 pub const VERSION_FIELD: &'static MessageField = &MessageField {
11808 name: "version",
11809 json_name: "version",
11810 number: 1i32,
11811 message_fields: None,
11812 };
11813 pub const MODULES_FIELD: &'static MessageField = &MessageField {
11814 name: "modules",
11815 json_name: "modules",
11816 number: 2i32,
11817 message_fields: None,
11818 };
11819 pub const DEPENDENCIES_FIELD: &'static MessageField = &MessageField {
11820 name: "dependencies",
11821 json_name: "dependencies",
11822 number: 3i32,
11823 message_fields: None,
11824 };
11825 }
11826 impl MessageFields for SystemPackage {
11827 const FIELDS: &'static [&'static MessageField] = &[
11828 Self::VERSION_FIELD,
11829 Self::MODULES_FIELD,
11830 Self::DEPENDENCIES_FIELD,
11831 ];
11832 }
11833 impl SystemPackage {
11834 pub fn path_builder() -> SystemPackageFieldPathBuilder {
11835 SystemPackageFieldPathBuilder::new()
11836 }
11837 }
11838 pub struct SystemPackageFieldPathBuilder {
11839 path: Vec<&'static str>,
11840 }
11841 impl SystemPackageFieldPathBuilder {
11842 #[allow(clippy::new_without_default)]
11843 pub fn new() -> Self {
11844 Self { path: Default::default() }
11845 }
11846 #[doc(hidden)]
11847 pub fn new_with_base(base: Vec<&'static str>) -> Self {
11848 Self { path: base }
11849 }
11850 pub fn finish(self) -> String {
11851 self.path.join(".")
11852 }
11853 pub fn version(mut self) -> String {
11854 self.path.push(SystemPackage::VERSION_FIELD.name);
11855 self.finish()
11856 }
11857 pub fn modules(mut self) -> String {
11858 self.path.push(SystemPackage::MODULES_FIELD.name);
11859 self.finish()
11860 }
11861 pub fn dependencies(mut self) -> String {
11862 self.path.push(SystemPackage::DEPENDENCIES_FIELD.name);
11863 self.finish()
11864 }
11865 }
11866 impl GenesisTransaction {
11867 pub const OBJECTS_FIELD: &'static MessageField = &MessageField {
11868 name: "objects",
11869 json_name: "objects",
11870 number: 1i32,
11871 message_fields: Some(Object::FIELDS),
11872 };
11873 }
11874 impl MessageFields for GenesisTransaction {
11875 const FIELDS: &'static [&'static MessageField] = &[Self::OBJECTS_FIELD];
11876 }
11877 impl GenesisTransaction {
11878 pub fn path_builder() -> GenesisTransactionFieldPathBuilder {
11879 GenesisTransactionFieldPathBuilder::new()
11880 }
11881 }
11882 pub struct GenesisTransactionFieldPathBuilder {
11883 path: Vec<&'static str>,
11884 }
11885 impl GenesisTransactionFieldPathBuilder {
11886 #[allow(clippy::new_without_default)]
11887 pub fn new() -> Self {
11888 Self { path: Default::default() }
11889 }
11890 #[doc(hidden)]
11891 pub fn new_with_base(base: Vec<&'static str>) -> Self {
11892 Self { path: base }
11893 }
11894 pub fn finish(self) -> String {
11895 self.path.join(".")
11896 }
11897 pub fn objects(mut self) -> ObjectFieldPathBuilder {
11898 self.path.push(GenesisTransaction::OBJECTS_FIELD.name);
11899 ObjectFieldPathBuilder::new_with_base(self.path)
11900 }
11901 }
11902 impl ConsensusCommitPrologue {
11903 pub const EPOCH_FIELD: &'static MessageField = &MessageField {
11904 name: "epoch",
11905 json_name: "epoch",
11906 number: 1i32,
11907 message_fields: None,
11908 };
11909 pub const ROUND_FIELD: &'static MessageField = &MessageField {
11910 name: "round",
11911 json_name: "round",
11912 number: 2i32,
11913 message_fields: None,
11914 };
11915 pub const COMMIT_TIMESTAMP_FIELD: &'static MessageField = &MessageField {
11916 name: "commit_timestamp",
11917 json_name: "commitTimestamp",
11918 number: 3i32,
11919 message_fields: None,
11920 };
11921 pub const CONSENSUS_COMMIT_DIGEST_FIELD: &'static MessageField = &MessageField {
11922 name: "consensus_commit_digest",
11923 json_name: "consensusCommitDigest",
11924 number: 4i32,
11925 message_fields: None,
11926 };
11927 pub const SUB_DAG_INDEX_FIELD: &'static MessageField = &MessageField {
11928 name: "sub_dag_index",
11929 json_name: "subDagIndex",
11930 number: 5i32,
11931 message_fields: None,
11932 };
11933 pub const CONSENSUS_DETERMINED_VERSION_ASSIGNMENTS_FIELD: &'static MessageField = &MessageField {
11934 name: "consensus_determined_version_assignments",
11935 json_name: "consensusDeterminedVersionAssignments",
11936 number: 6i32,
11937 message_fields: Some(ConsensusDeterminedVersionAssignments::FIELDS),
11938 };
11939 pub const ADDITIONAL_STATE_DIGEST_FIELD: &'static MessageField = &MessageField {
11940 name: "additional_state_digest",
11941 json_name: "additionalStateDigest",
11942 number: 7i32,
11943 message_fields: None,
11944 };
11945 }
11946 impl MessageFields for ConsensusCommitPrologue {
11947 const FIELDS: &'static [&'static MessageField] = &[
11948 Self::EPOCH_FIELD,
11949 Self::ROUND_FIELD,
11950 Self::COMMIT_TIMESTAMP_FIELD,
11951 Self::CONSENSUS_COMMIT_DIGEST_FIELD,
11952 Self::SUB_DAG_INDEX_FIELD,
11953 Self::CONSENSUS_DETERMINED_VERSION_ASSIGNMENTS_FIELD,
11954 Self::ADDITIONAL_STATE_DIGEST_FIELD,
11955 ];
11956 }
11957 impl ConsensusCommitPrologue {
11958 pub fn path_builder() -> ConsensusCommitPrologueFieldPathBuilder {
11959 ConsensusCommitPrologueFieldPathBuilder::new()
11960 }
11961 }
11962 pub struct ConsensusCommitPrologueFieldPathBuilder {
11963 path: Vec<&'static str>,
11964 }
11965 impl ConsensusCommitPrologueFieldPathBuilder {
11966 #[allow(clippy::new_without_default)]
11967 pub fn new() -> Self {
11968 Self { path: Default::default() }
11969 }
11970 #[doc(hidden)]
11971 pub fn new_with_base(base: Vec<&'static str>) -> Self {
11972 Self { path: base }
11973 }
11974 pub fn finish(self) -> String {
11975 self.path.join(".")
11976 }
11977 pub fn epoch(mut self) -> String {
11978 self.path.push(ConsensusCommitPrologue::EPOCH_FIELD.name);
11979 self.finish()
11980 }
11981 pub fn round(mut self) -> String {
11982 self.path.push(ConsensusCommitPrologue::ROUND_FIELD.name);
11983 self.finish()
11984 }
11985 pub fn commit_timestamp(mut self) -> String {
11986 self.path.push(ConsensusCommitPrologue::COMMIT_TIMESTAMP_FIELD.name);
11987 self.finish()
11988 }
11989 pub fn consensus_commit_digest(mut self) -> String {
11990 self.path.push(ConsensusCommitPrologue::CONSENSUS_COMMIT_DIGEST_FIELD.name);
11991 self.finish()
11992 }
11993 pub fn sub_dag_index(mut self) -> String {
11994 self.path.push(ConsensusCommitPrologue::SUB_DAG_INDEX_FIELD.name);
11995 self.finish()
11996 }
11997 pub fn consensus_determined_version_assignments(
11998 mut self,
11999 ) -> ConsensusDeterminedVersionAssignmentsFieldPathBuilder {
12000 self.path
12001 .push(
12002 ConsensusCommitPrologue::CONSENSUS_DETERMINED_VERSION_ASSIGNMENTS_FIELD
12003 .name,
12004 );
12005 ConsensusDeterminedVersionAssignmentsFieldPathBuilder::new_with_base(
12006 self.path,
12007 )
12008 }
12009 pub fn additional_state_digest(mut self) -> String {
12010 self.path.push(ConsensusCommitPrologue::ADDITIONAL_STATE_DIGEST_FIELD.name);
12011 self.finish()
12012 }
12013 }
12014 impl VersionAssignment {
12015 pub const OBJECT_ID_FIELD: &'static MessageField = &MessageField {
12016 name: "object_id",
12017 json_name: "objectId",
12018 number: 1i32,
12019 message_fields: None,
12020 };
12021 pub const START_VERSION_FIELD: &'static MessageField = &MessageField {
12022 name: "start_version",
12023 json_name: "startVersion",
12024 number: 2i32,
12025 message_fields: None,
12026 };
12027 pub const VERSION_FIELD: &'static MessageField = &MessageField {
12028 name: "version",
12029 json_name: "version",
12030 number: 3i32,
12031 message_fields: None,
12032 };
12033 }
12034 impl MessageFields for VersionAssignment {
12035 const FIELDS: &'static [&'static MessageField] = &[
12036 Self::OBJECT_ID_FIELD,
12037 Self::START_VERSION_FIELD,
12038 Self::VERSION_FIELD,
12039 ];
12040 }
12041 impl VersionAssignment {
12042 pub fn path_builder() -> VersionAssignmentFieldPathBuilder {
12043 VersionAssignmentFieldPathBuilder::new()
12044 }
12045 }
12046 pub struct VersionAssignmentFieldPathBuilder {
12047 path: Vec<&'static str>,
12048 }
12049 impl VersionAssignmentFieldPathBuilder {
12050 #[allow(clippy::new_without_default)]
12051 pub fn new() -> Self {
12052 Self { path: Default::default() }
12053 }
12054 #[doc(hidden)]
12055 pub fn new_with_base(base: Vec<&'static str>) -> Self {
12056 Self { path: base }
12057 }
12058 pub fn finish(self) -> String {
12059 self.path.join(".")
12060 }
12061 pub fn object_id(mut self) -> String {
12062 self.path.push(VersionAssignment::OBJECT_ID_FIELD.name);
12063 self.finish()
12064 }
12065 pub fn start_version(mut self) -> String {
12066 self.path.push(VersionAssignment::START_VERSION_FIELD.name);
12067 self.finish()
12068 }
12069 pub fn version(mut self) -> String {
12070 self.path.push(VersionAssignment::VERSION_FIELD.name);
12071 self.finish()
12072 }
12073 }
12074 impl CanceledTransaction {
12075 pub const DIGEST_FIELD: &'static MessageField = &MessageField {
12076 name: "digest",
12077 json_name: "digest",
12078 number: 1i32,
12079 message_fields: None,
12080 };
12081 pub const VERSION_ASSIGNMENTS_FIELD: &'static MessageField = &MessageField {
12082 name: "version_assignments",
12083 json_name: "versionAssignments",
12084 number: 2i32,
12085 message_fields: Some(VersionAssignment::FIELDS),
12086 };
12087 }
12088 impl MessageFields for CanceledTransaction {
12089 const FIELDS: &'static [&'static MessageField] = &[
12090 Self::DIGEST_FIELD,
12091 Self::VERSION_ASSIGNMENTS_FIELD,
12092 ];
12093 }
12094 impl CanceledTransaction {
12095 pub fn path_builder() -> CanceledTransactionFieldPathBuilder {
12096 CanceledTransactionFieldPathBuilder::new()
12097 }
12098 }
12099 pub struct CanceledTransactionFieldPathBuilder {
12100 path: Vec<&'static str>,
12101 }
12102 impl CanceledTransactionFieldPathBuilder {
12103 #[allow(clippy::new_without_default)]
12104 pub fn new() -> Self {
12105 Self { path: Default::default() }
12106 }
12107 #[doc(hidden)]
12108 pub fn new_with_base(base: Vec<&'static str>) -> Self {
12109 Self { path: base }
12110 }
12111 pub fn finish(self) -> String {
12112 self.path.join(".")
12113 }
12114 pub fn digest(mut self) -> String {
12115 self.path.push(CanceledTransaction::DIGEST_FIELD.name);
12116 self.finish()
12117 }
12118 pub fn version_assignments(mut self) -> VersionAssignmentFieldPathBuilder {
12119 self.path.push(CanceledTransaction::VERSION_ASSIGNMENTS_FIELD.name);
12120 VersionAssignmentFieldPathBuilder::new_with_base(self.path)
12121 }
12122 }
12123 impl ConsensusDeterminedVersionAssignments {
12124 pub const VERSION_FIELD: &'static MessageField = &MessageField {
12125 name: "version",
12126 json_name: "version",
12127 number: 1i32,
12128 message_fields: None,
12129 };
12130 pub const CANCELED_TRANSACTIONS_FIELD: &'static MessageField = &MessageField {
12131 name: "canceled_transactions",
12132 json_name: "canceledTransactions",
12133 number: 3i32,
12134 message_fields: Some(CanceledTransaction::FIELDS),
12135 };
12136 }
12137 impl MessageFields for ConsensusDeterminedVersionAssignments {
12138 const FIELDS: &'static [&'static MessageField] = &[
12139 Self::VERSION_FIELD,
12140 Self::CANCELED_TRANSACTIONS_FIELD,
12141 ];
12142 }
12143 impl ConsensusDeterminedVersionAssignments {
12144 pub fn path_builder() -> ConsensusDeterminedVersionAssignmentsFieldPathBuilder {
12145 ConsensusDeterminedVersionAssignmentsFieldPathBuilder::new()
12146 }
12147 }
12148 pub struct ConsensusDeterminedVersionAssignmentsFieldPathBuilder {
12149 path: Vec<&'static str>,
12150 }
12151 impl ConsensusDeterminedVersionAssignmentsFieldPathBuilder {
12152 #[allow(clippy::new_without_default)]
12153 pub fn new() -> Self {
12154 Self { path: Default::default() }
12155 }
12156 #[doc(hidden)]
12157 pub fn new_with_base(base: Vec<&'static str>) -> Self {
12158 Self { path: base }
12159 }
12160 pub fn finish(self) -> String {
12161 self.path.join(".")
12162 }
12163 pub fn version(mut self) -> String {
12164 self.path.push(ConsensusDeterminedVersionAssignments::VERSION_FIELD.name);
12165 self.finish()
12166 }
12167 pub fn canceled_transactions(mut self) -> CanceledTransactionFieldPathBuilder {
12168 self.path
12169 .push(
12170 ConsensusDeterminedVersionAssignments::CANCELED_TRANSACTIONS_FIELD
12171 .name,
12172 );
12173 CanceledTransactionFieldPathBuilder::new_with_base(self.path)
12174 }
12175 }
12176 impl AuthenticatorStateUpdate {
12177 pub const EPOCH_FIELD: &'static MessageField = &MessageField {
12178 name: "epoch",
12179 json_name: "epoch",
12180 number: 1i32,
12181 message_fields: None,
12182 };
12183 pub const ROUND_FIELD: &'static MessageField = &MessageField {
12184 name: "round",
12185 json_name: "round",
12186 number: 2i32,
12187 message_fields: None,
12188 };
12189 pub const NEW_ACTIVE_JWKS_FIELD: &'static MessageField = &MessageField {
12190 name: "new_active_jwks",
12191 json_name: "newActiveJwks",
12192 number: 3i32,
12193 message_fields: Some(ActiveJwk::FIELDS),
12194 };
12195 pub const AUTHENTICATOR_OBJECT_INITIAL_SHARED_VERSION_FIELD: &'static MessageField = &MessageField {
12196 name: "authenticator_object_initial_shared_version",
12197 json_name: "authenticatorObjectInitialSharedVersion",
12198 number: 4i32,
12199 message_fields: None,
12200 };
12201 }
12202 impl MessageFields for AuthenticatorStateUpdate {
12203 const FIELDS: &'static [&'static MessageField] = &[
12204 Self::EPOCH_FIELD,
12205 Self::ROUND_FIELD,
12206 Self::NEW_ACTIVE_JWKS_FIELD,
12207 Self::AUTHENTICATOR_OBJECT_INITIAL_SHARED_VERSION_FIELD,
12208 ];
12209 }
12210 impl AuthenticatorStateUpdate {
12211 pub fn path_builder() -> AuthenticatorStateUpdateFieldPathBuilder {
12212 AuthenticatorStateUpdateFieldPathBuilder::new()
12213 }
12214 }
12215 pub struct AuthenticatorStateUpdateFieldPathBuilder {
12216 path: Vec<&'static str>,
12217 }
12218 impl AuthenticatorStateUpdateFieldPathBuilder {
12219 #[allow(clippy::new_without_default)]
12220 pub fn new() -> Self {
12221 Self { path: Default::default() }
12222 }
12223 #[doc(hidden)]
12224 pub fn new_with_base(base: Vec<&'static str>) -> Self {
12225 Self { path: base }
12226 }
12227 pub fn finish(self) -> String {
12228 self.path.join(".")
12229 }
12230 pub fn epoch(mut self) -> String {
12231 self.path.push(AuthenticatorStateUpdate::EPOCH_FIELD.name);
12232 self.finish()
12233 }
12234 pub fn round(mut self) -> String {
12235 self.path.push(AuthenticatorStateUpdate::ROUND_FIELD.name);
12236 self.finish()
12237 }
12238 pub fn new_active_jwks(mut self) -> ActiveJwkFieldPathBuilder {
12239 self.path.push(AuthenticatorStateUpdate::NEW_ACTIVE_JWKS_FIELD.name);
12240 ActiveJwkFieldPathBuilder::new_with_base(self.path)
12241 }
12242 pub fn authenticator_object_initial_shared_version(mut self) -> String {
12243 self.path
12244 .push(
12245 AuthenticatorStateUpdate::AUTHENTICATOR_OBJECT_INITIAL_SHARED_VERSION_FIELD
12246 .name,
12247 );
12248 self.finish()
12249 }
12250 }
12251 impl ActiveJwk {
12252 pub const ID_FIELD: &'static MessageField = &MessageField {
12253 name: "id",
12254 json_name: "id",
12255 number: 1i32,
12256 message_fields: Some(JwkId::FIELDS),
12257 };
12258 pub const JWK_FIELD: &'static MessageField = &MessageField {
12259 name: "jwk",
12260 json_name: "jwk",
12261 number: 2i32,
12262 message_fields: Some(Jwk::FIELDS),
12263 };
12264 pub const EPOCH_FIELD: &'static MessageField = &MessageField {
12265 name: "epoch",
12266 json_name: "epoch",
12267 number: 3i32,
12268 message_fields: None,
12269 };
12270 }
12271 impl MessageFields for ActiveJwk {
12272 const FIELDS: &'static [&'static MessageField] = &[
12273 Self::ID_FIELD,
12274 Self::JWK_FIELD,
12275 Self::EPOCH_FIELD,
12276 ];
12277 }
12278 impl ActiveJwk {
12279 pub fn path_builder() -> ActiveJwkFieldPathBuilder {
12280 ActiveJwkFieldPathBuilder::new()
12281 }
12282 }
12283 pub struct ActiveJwkFieldPathBuilder {
12284 path: Vec<&'static str>,
12285 }
12286 impl ActiveJwkFieldPathBuilder {
12287 #[allow(clippy::new_without_default)]
12288 pub fn new() -> Self {
12289 Self { path: Default::default() }
12290 }
12291 #[doc(hidden)]
12292 pub fn new_with_base(base: Vec<&'static str>) -> Self {
12293 Self { path: base }
12294 }
12295 pub fn finish(self) -> String {
12296 self.path.join(".")
12297 }
12298 pub fn id(mut self) -> JwkIdFieldPathBuilder {
12299 self.path.push(ActiveJwk::ID_FIELD.name);
12300 JwkIdFieldPathBuilder::new_with_base(self.path)
12301 }
12302 pub fn jwk(mut self) -> JwkFieldPathBuilder {
12303 self.path.push(ActiveJwk::JWK_FIELD.name);
12304 JwkFieldPathBuilder::new_with_base(self.path)
12305 }
12306 pub fn epoch(mut self) -> String {
12307 self.path.push(ActiveJwk::EPOCH_FIELD.name);
12308 self.finish()
12309 }
12310 }
12311 impl EndOfEpochTransaction {
12312 pub const TRANSACTIONS_FIELD: &'static MessageField = &MessageField {
12313 name: "transactions",
12314 json_name: "transactions",
12315 number: 1i32,
12316 message_fields: Some(EndOfEpochTransactionKind::FIELDS),
12317 };
12318 }
12319 impl MessageFields for EndOfEpochTransaction {
12320 const FIELDS: &'static [&'static MessageField] = &[Self::TRANSACTIONS_FIELD];
12321 }
12322 impl EndOfEpochTransaction {
12323 pub fn path_builder() -> EndOfEpochTransactionFieldPathBuilder {
12324 EndOfEpochTransactionFieldPathBuilder::new()
12325 }
12326 }
12327 pub struct EndOfEpochTransactionFieldPathBuilder {
12328 path: Vec<&'static str>,
12329 }
12330 impl EndOfEpochTransactionFieldPathBuilder {
12331 #[allow(clippy::new_without_default)]
12332 pub fn new() -> Self {
12333 Self { path: Default::default() }
12334 }
12335 #[doc(hidden)]
12336 pub fn new_with_base(base: Vec<&'static str>) -> Self {
12337 Self { path: base }
12338 }
12339 pub fn finish(self) -> String {
12340 self.path.join(".")
12341 }
12342 pub fn transactions(mut self) -> EndOfEpochTransactionKindFieldPathBuilder {
12343 self.path.push(EndOfEpochTransaction::TRANSACTIONS_FIELD.name);
12344 EndOfEpochTransactionKindFieldPathBuilder::new_with_base(self.path)
12345 }
12346 }
12347 impl EndOfEpochTransactionKind {
12348 pub const KIND_FIELD: &'static MessageField = &MessageField {
12349 name: "kind",
12350 json_name: "kind",
12351 number: 1i32,
12352 message_fields: None,
12353 };
12354 pub const CHANGE_EPOCH_FIELD: &'static MessageField = &MessageField {
12355 name: "change_epoch",
12356 json_name: "changeEpoch",
12357 number: 2i32,
12358 message_fields: Some(ChangeEpoch::FIELDS),
12359 };
12360 pub const AUTHENTICATOR_STATE_EXPIRE_FIELD: &'static MessageField = &MessageField {
12361 name: "authenticator_state_expire",
12362 json_name: "authenticatorStateExpire",
12363 number: 3i32,
12364 message_fields: Some(AuthenticatorStateExpire::FIELDS),
12365 };
12366 pub const EXECUTION_TIME_OBSERVATIONS_FIELD: &'static MessageField = &MessageField {
12367 name: "execution_time_observations",
12368 json_name: "executionTimeObservations",
12369 number: 4i32,
12370 message_fields: Some(ExecutionTimeObservations::FIELDS),
12371 };
12372 pub const BRIDGE_CHAIN_ID_FIELD: &'static MessageField = &MessageField {
12373 name: "bridge_chain_id",
12374 json_name: "bridgeChainId",
12375 number: 5i32,
12376 message_fields: None,
12377 };
12378 pub const BRIDGE_OBJECT_VERSION_FIELD: &'static MessageField = &MessageField {
12379 name: "bridge_object_version",
12380 json_name: "bridgeObjectVersion",
12381 number: 6i32,
12382 message_fields: None,
12383 };
12384 pub const STORAGE_COST_FIELD: &'static MessageField = &MessageField {
12385 name: "storage_cost",
12386 json_name: "storageCost",
12387 number: 7i32,
12388 message_fields: None,
12389 };
12390 }
12391 impl MessageFields for EndOfEpochTransactionKind {
12392 const FIELDS: &'static [&'static MessageField] = &[
12393 Self::KIND_FIELD,
12394 Self::CHANGE_EPOCH_FIELD,
12395 Self::AUTHENTICATOR_STATE_EXPIRE_FIELD,
12396 Self::EXECUTION_TIME_OBSERVATIONS_FIELD,
12397 Self::BRIDGE_CHAIN_ID_FIELD,
12398 Self::BRIDGE_OBJECT_VERSION_FIELD,
12399 Self::STORAGE_COST_FIELD,
12400 ];
12401 }
12402 impl EndOfEpochTransactionKind {
12403 pub fn path_builder() -> EndOfEpochTransactionKindFieldPathBuilder {
12404 EndOfEpochTransactionKindFieldPathBuilder::new()
12405 }
12406 }
12407 pub struct EndOfEpochTransactionKindFieldPathBuilder {
12408 path: Vec<&'static str>,
12409 }
12410 impl EndOfEpochTransactionKindFieldPathBuilder {
12411 #[allow(clippy::new_without_default)]
12412 pub fn new() -> Self {
12413 Self { path: Default::default() }
12414 }
12415 #[doc(hidden)]
12416 pub fn new_with_base(base: Vec<&'static str>) -> Self {
12417 Self { path: base }
12418 }
12419 pub fn finish(self) -> String {
12420 self.path.join(".")
12421 }
12422 pub fn kind(mut self) -> String {
12423 self.path.push(EndOfEpochTransactionKind::KIND_FIELD.name);
12424 self.finish()
12425 }
12426 pub fn change_epoch(mut self) -> ChangeEpochFieldPathBuilder {
12427 self.path.push(EndOfEpochTransactionKind::CHANGE_EPOCH_FIELD.name);
12428 ChangeEpochFieldPathBuilder::new_with_base(self.path)
12429 }
12430 pub fn authenticator_state_expire(
12431 mut self,
12432 ) -> AuthenticatorStateExpireFieldPathBuilder {
12433 self.path
12434 .push(EndOfEpochTransactionKind::AUTHENTICATOR_STATE_EXPIRE_FIELD.name);
12435 AuthenticatorStateExpireFieldPathBuilder::new_with_base(self.path)
12436 }
12437 pub fn execution_time_observations(
12438 mut self,
12439 ) -> ExecutionTimeObservationsFieldPathBuilder {
12440 self.path
12441 .push(EndOfEpochTransactionKind::EXECUTION_TIME_OBSERVATIONS_FIELD.name);
12442 ExecutionTimeObservationsFieldPathBuilder::new_with_base(self.path)
12443 }
12444 pub fn bridge_chain_id(mut self) -> String {
12445 self.path.push(EndOfEpochTransactionKind::BRIDGE_CHAIN_ID_FIELD.name);
12446 self.finish()
12447 }
12448 pub fn bridge_object_version(mut self) -> String {
12449 self.path.push(EndOfEpochTransactionKind::BRIDGE_OBJECT_VERSION_FIELD.name);
12450 self.finish()
12451 }
12452 pub fn storage_cost(mut self) -> String {
12453 self.path.push(EndOfEpochTransactionKind::STORAGE_COST_FIELD.name);
12454 self.finish()
12455 }
12456 }
12457 impl AuthenticatorStateExpire {
12458 pub const MIN_EPOCH_FIELD: &'static MessageField = &MessageField {
12459 name: "min_epoch",
12460 json_name: "minEpoch",
12461 number: 1i32,
12462 message_fields: None,
12463 };
12464 pub const AUTHENTICATOR_OBJECT_INITIAL_SHARED_VERSION_FIELD: &'static MessageField = &MessageField {
12465 name: "authenticator_object_initial_shared_version",
12466 json_name: "authenticatorObjectInitialSharedVersion",
12467 number: 2i32,
12468 message_fields: None,
12469 };
12470 }
12471 impl MessageFields for AuthenticatorStateExpire {
12472 const FIELDS: &'static [&'static MessageField] = &[
12473 Self::MIN_EPOCH_FIELD,
12474 Self::AUTHENTICATOR_OBJECT_INITIAL_SHARED_VERSION_FIELD,
12475 ];
12476 }
12477 impl AuthenticatorStateExpire {
12478 pub fn path_builder() -> AuthenticatorStateExpireFieldPathBuilder {
12479 AuthenticatorStateExpireFieldPathBuilder::new()
12480 }
12481 }
12482 pub struct AuthenticatorStateExpireFieldPathBuilder {
12483 path: Vec<&'static str>,
12484 }
12485 impl AuthenticatorStateExpireFieldPathBuilder {
12486 #[allow(clippy::new_without_default)]
12487 pub fn new() -> Self {
12488 Self { path: Default::default() }
12489 }
12490 #[doc(hidden)]
12491 pub fn new_with_base(base: Vec<&'static str>) -> Self {
12492 Self { path: base }
12493 }
12494 pub fn finish(self) -> String {
12495 self.path.join(".")
12496 }
12497 pub fn min_epoch(mut self) -> String {
12498 self.path.push(AuthenticatorStateExpire::MIN_EPOCH_FIELD.name);
12499 self.finish()
12500 }
12501 pub fn authenticator_object_initial_shared_version(mut self) -> String {
12502 self.path
12503 .push(
12504 AuthenticatorStateExpire::AUTHENTICATOR_OBJECT_INITIAL_SHARED_VERSION_FIELD
12505 .name,
12506 );
12507 self.finish()
12508 }
12509 }
12510 impl ExecutionTimeObservations {
12511 pub const VERSION_FIELD: &'static MessageField = &MessageField {
12512 name: "version",
12513 json_name: "version",
12514 number: 1i32,
12515 message_fields: None,
12516 };
12517 pub const OBSERVATIONS_FIELD: &'static MessageField = &MessageField {
12518 name: "observations",
12519 json_name: "observations",
12520 number: 2i32,
12521 message_fields: Some(ExecutionTimeObservation::FIELDS),
12522 };
12523 }
12524 impl MessageFields for ExecutionTimeObservations {
12525 const FIELDS: &'static [&'static MessageField] = &[
12526 Self::VERSION_FIELD,
12527 Self::OBSERVATIONS_FIELD,
12528 ];
12529 }
12530 impl ExecutionTimeObservations {
12531 pub fn path_builder() -> ExecutionTimeObservationsFieldPathBuilder {
12532 ExecutionTimeObservationsFieldPathBuilder::new()
12533 }
12534 }
12535 pub struct ExecutionTimeObservationsFieldPathBuilder {
12536 path: Vec<&'static str>,
12537 }
12538 impl ExecutionTimeObservationsFieldPathBuilder {
12539 #[allow(clippy::new_without_default)]
12540 pub fn new() -> Self {
12541 Self { path: Default::default() }
12542 }
12543 #[doc(hidden)]
12544 pub fn new_with_base(base: Vec<&'static str>) -> Self {
12545 Self { path: base }
12546 }
12547 pub fn finish(self) -> String {
12548 self.path.join(".")
12549 }
12550 pub fn version(mut self) -> String {
12551 self.path.push(ExecutionTimeObservations::VERSION_FIELD.name);
12552 self.finish()
12553 }
12554 pub fn observations(mut self) -> ExecutionTimeObservationFieldPathBuilder {
12555 self.path.push(ExecutionTimeObservations::OBSERVATIONS_FIELD.name);
12556 ExecutionTimeObservationFieldPathBuilder::new_with_base(self.path)
12557 }
12558 }
12559 impl ExecutionTimeObservation {
12560 pub const KIND_FIELD: &'static MessageField = &MessageField {
12561 name: "kind",
12562 json_name: "kind",
12563 number: 1i32,
12564 message_fields: None,
12565 };
12566 pub const MOVE_ENTRY_POINT_FIELD: &'static MessageField = &MessageField {
12567 name: "move_entry_point",
12568 json_name: "moveEntryPoint",
12569 number: 2i32,
12570 message_fields: Some(MoveCall::FIELDS),
12571 };
12572 pub const VALIDATOR_OBSERVATIONS_FIELD: &'static MessageField = &MessageField {
12573 name: "validator_observations",
12574 json_name: "validatorObservations",
12575 number: 3i32,
12576 message_fields: Some(ValidatorExecutionTimeObservation::FIELDS),
12577 };
12578 }
12579 impl MessageFields for ExecutionTimeObservation {
12580 const FIELDS: &'static [&'static MessageField] = &[
12581 Self::KIND_FIELD,
12582 Self::MOVE_ENTRY_POINT_FIELD,
12583 Self::VALIDATOR_OBSERVATIONS_FIELD,
12584 ];
12585 }
12586 impl ExecutionTimeObservation {
12587 pub fn path_builder() -> ExecutionTimeObservationFieldPathBuilder {
12588 ExecutionTimeObservationFieldPathBuilder::new()
12589 }
12590 }
12591 pub struct ExecutionTimeObservationFieldPathBuilder {
12592 path: Vec<&'static str>,
12593 }
12594 impl ExecutionTimeObservationFieldPathBuilder {
12595 #[allow(clippy::new_without_default)]
12596 pub fn new() -> Self {
12597 Self { path: Default::default() }
12598 }
12599 #[doc(hidden)]
12600 pub fn new_with_base(base: Vec<&'static str>) -> Self {
12601 Self { path: base }
12602 }
12603 pub fn finish(self) -> String {
12604 self.path.join(".")
12605 }
12606 pub fn kind(mut self) -> String {
12607 self.path.push(ExecutionTimeObservation::KIND_FIELD.name);
12608 self.finish()
12609 }
12610 pub fn move_entry_point(mut self) -> MoveCallFieldPathBuilder {
12611 self.path.push(ExecutionTimeObservation::MOVE_ENTRY_POINT_FIELD.name);
12612 MoveCallFieldPathBuilder::new_with_base(self.path)
12613 }
12614 pub fn validator_observations(
12615 mut self,
12616 ) -> ValidatorExecutionTimeObservationFieldPathBuilder {
12617 self.path.push(ExecutionTimeObservation::VALIDATOR_OBSERVATIONS_FIELD.name);
12618 ValidatorExecutionTimeObservationFieldPathBuilder::new_with_base(self.path)
12619 }
12620 }
12621 impl ValidatorExecutionTimeObservation {
12622 pub const VALIDATOR_FIELD: &'static MessageField = &MessageField {
12623 name: "validator",
12624 json_name: "validator",
12625 number: 1i32,
12626 message_fields: None,
12627 };
12628 pub const DURATION_FIELD: &'static MessageField = &MessageField {
12629 name: "duration",
12630 json_name: "duration",
12631 number: 2i32,
12632 message_fields: None,
12633 };
12634 }
12635 impl MessageFields for ValidatorExecutionTimeObservation {
12636 const FIELDS: &'static [&'static MessageField] = &[
12637 Self::VALIDATOR_FIELD,
12638 Self::DURATION_FIELD,
12639 ];
12640 }
12641 impl ValidatorExecutionTimeObservation {
12642 pub fn path_builder() -> ValidatorExecutionTimeObservationFieldPathBuilder {
12643 ValidatorExecutionTimeObservationFieldPathBuilder::new()
12644 }
12645 }
12646 pub struct ValidatorExecutionTimeObservationFieldPathBuilder {
12647 path: Vec<&'static str>,
12648 }
12649 impl ValidatorExecutionTimeObservationFieldPathBuilder {
12650 #[allow(clippy::new_without_default)]
12651 pub fn new() -> Self {
12652 Self { path: Default::default() }
12653 }
12654 #[doc(hidden)]
12655 pub fn new_with_base(base: Vec<&'static str>) -> Self {
12656 Self { path: base }
12657 }
12658 pub fn finish(self) -> String {
12659 self.path.join(".")
12660 }
12661 pub fn validator(mut self) -> String {
12662 self.path.push(ValidatorExecutionTimeObservation::VALIDATOR_FIELD.name);
12663 self.finish()
12664 }
12665 pub fn duration(mut self) -> String {
12666 self.path.push(ValidatorExecutionTimeObservation::DURATION_FIELD.name);
12667 self.finish()
12668 }
12669 }
12670 impl ExecuteTransactionRequest {
12671 pub const TRANSACTION_FIELD: &'static MessageField = &MessageField {
12672 name: "transaction",
12673 json_name: "transaction",
12674 number: 1i32,
12675 message_fields: Some(Transaction::FIELDS),
12676 };
12677 pub const SIGNATURES_FIELD: &'static MessageField = &MessageField {
12678 name: "signatures",
12679 json_name: "signatures",
12680 number: 2i32,
12681 message_fields: Some(UserSignature::FIELDS),
12682 };
12683 pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
12684 name: "read_mask",
12685 json_name: "readMask",
12686 number: 3i32,
12687 message_fields: None,
12688 };
12689 }
12690 impl MessageFields for ExecuteTransactionRequest {
12691 const FIELDS: &'static [&'static MessageField] = &[
12692 Self::TRANSACTION_FIELD,
12693 Self::SIGNATURES_FIELD,
12694 Self::READ_MASK_FIELD,
12695 ];
12696 }
12697 impl ExecuteTransactionRequest {
12698 pub fn path_builder() -> ExecuteTransactionRequestFieldPathBuilder {
12699 ExecuteTransactionRequestFieldPathBuilder::new()
12700 }
12701 }
12702 pub struct ExecuteTransactionRequestFieldPathBuilder {
12703 path: Vec<&'static str>,
12704 }
12705 impl ExecuteTransactionRequestFieldPathBuilder {
12706 #[allow(clippy::new_without_default)]
12707 pub fn new() -> Self {
12708 Self { path: Default::default() }
12709 }
12710 #[doc(hidden)]
12711 pub fn new_with_base(base: Vec<&'static str>) -> Self {
12712 Self { path: base }
12713 }
12714 pub fn finish(self) -> String {
12715 self.path.join(".")
12716 }
12717 pub fn transaction(mut self) -> TransactionFieldPathBuilder {
12718 self.path.push(ExecuteTransactionRequest::TRANSACTION_FIELD.name);
12719 TransactionFieldPathBuilder::new_with_base(self.path)
12720 }
12721 pub fn signatures(mut self) -> UserSignatureFieldPathBuilder {
12722 self.path.push(ExecuteTransactionRequest::SIGNATURES_FIELD.name);
12723 UserSignatureFieldPathBuilder::new_with_base(self.path)
12724 }
12725 pub fn read_mask(mut self) -> String {
12726 self.path.push(ExecuteTransactionRequest::READ_MASK_FIELD.name);
12727 self.finish()
12728 }
12729 }
12730 impl ExecuteTransactionResponse {
12731 pub const TRANSACTION_FIELD: &'static MessageField = &MessageField {
12732 name: "transaction",
12733 json_name: "transaction",
12734 number: 1i32,
12735 message_fields: Some(ExecutedTransaction::FIELDS),
12736 };
12737 }
12738 impl MessageFields for ExecuteTransactionResponse {
12739 const FIELDS: &'static [&'static MessageField] = &[Self::TRANSACTION_FIELD];
12740 }
12741 impl ExecuteTransactionResponse {
12742 pub fn path_builder() -> ExecuteTransactionResponseFieldPathBuilder {
12743 ExecuteTransactionResponseFieldPathBuilder::new()
12744 }
12745 }
12746 pub struct ExecuteTransactionResponseFieldPathBuilder {
12747 path: Vec<&'static str>,
12748 }
12749 impl ExecuteTransactionResponseFieldPathBuilder {
12750 #[allow(clippy::new_without_default)]
12751 pub fn new() -> Self {
12752 Self { path: Default::default() }
12753 }
12754 #[doc(hidden)]
12755 pub fn new_with_base(base: Vec<&'static str>) -> Self {
12756 Self { path: base }
12757 }
12758 pub fn finish(self) -> String {
12759 self.path.join(".")
12760 }
12761 pub fn transaction(mut self) -> ExecutedTransactionFieldPathBuilder {
12762 self.path.push(ExecuteTransactionResponse::TRANSACTION_FIELD.name);
12763 ExecutedTransactionFieldPathBuilder::new_with_base(self.path)
12764 }
12765 }
12766 impl SimulateTransactionRequest {
12767 pub const TRANSACTION_FIELD: &'static MessageField = &MessageField {
12768 name: "transaction",
12769 json_name: "transaction",
12770 number: 1i32,
12771 message_fields: Some(Transaction::FIELDS),
12772 };
12773 pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
12774 name: "read_mask",
12775 json_name: "readMask",
12776 number: 2i32,
12777 message_fields: None,
12778 };
12779 pub const CHECKS_FIELD: &'static MessageField = &MessageField {
12780 name: "checks",
12781 json_name: "checks",
12782 number: 3i32,
12783 message_fields: None,
12784 };
12785 pub const DO_GAS_SELECTION_FIELD: &'static MessageField = &MessageField {
12786 name: "do_gas_selection",
12787 json_name: "doGasSelection",
12788 number: 4i32,
12789 message_fields: None,
12790 };
12791 }
12792 impl MessageFields for SimulateTransactionRequest {
12793 const FIELDS: &'static [&'static MessageField] = &[
12794 Self::TRANSACTION_FIELD,
12795 Self::READ_MASK_FIELD,
12796 Self::CHECKS_FIELD,
12797 Self::DO_GAS_SELECTION_FIELD,
12798 ];
12799 }
12800 impl SimulateTransactionRequest {
12801 pub fn path_builder() -> SimulateTransactionRequestFieldPathBuilder {
12802 SimulateTransactionRequestFieldPathBuilder::new()
12803 }
12804 }
12805 pub struct SimulateTransactionRequestFieldPathBuilder {
12806 path: Vec<&'static str>,
12807 }
12808 impl SimulateTransactionRequestFieldPathBuilder {
12809 #[allow(clippy::new_without_default)]
12810 pub fn new() -> Self {
12811 Self { path: Default::default() }
12812 }
12813 #[doc(hidden)]
12814 pub fn new_with_base(base: Vec<&'static str>) -> Self {
12815 Self { path: base }
12816 }
12817 pub fn finish(self) -> String {
12818 self.path.join(".")
12819 }
12820 pub fn transaction(mut self) -> TransactionFieldPathBuilder {
12821 self.path.push(SimulateTransactionRequest::TRANSACTION_FIELD.name);
12822 TransactionFieldPathBuilder::new_with_base(self.path)
12823 }
12824 pub fn read_mask(mut self) -> String {
12825 self.path.push(SimulateTransactionRequest::READ_MASK_FIELD.name);
12826 self.finish()
12827 }
12828 pub fn checks(mut self) -> String {
12829 self.path.push(SimulateTransactionRequest::CHECKS_FIELD.name);
12830 self.finish()
12831 }
12832 pub fn do_gas_selection(mut self) -> String {
12833 self.path.push(SimulateTransactionRequest::DO_GAS_SELECTION_FIELD.name);
12834 self.finish()
12835 }
12836 }
12837 impl SimulateTransactionResponse {
12838 pub const TRANSACTION_FIELD: &'static MessageField = &MessageField {
12839 name: "transaction",
12840 json_name: "transaction",
12841 number: 1i32,
12842 message_fields: Some(ExecutedTransaction::FIELDS),
12843 };
12844 pub const COMMAND_OUTPUTS_FIELD: &'static MessageField = &MessageField {
12845 name: "command_outputs",
12846 json_name: "commandOutputs",
12847 number: 2i32,
12848 message_fields: Some(CommandResult::FIELDS),
12849 };
12850 pub const SUGGESTED_GAS_PRICE_FIELD: &'static MessageField = &MessageField {
12851 name: "suggested_gas_price",
12852 json_name: "suggestedGasPrice",
12853 number: 3i32,
12854 message_fields: None,
12855 };
12856 }
12857 impl MessageFields for SimulateTransactionResponse {
12858 const FIELDS: &'static [&'static MessageField] = &[
12859 Self::TRANSACTION_FIELD,
12860 Self::COMMAND_OUTPUTS_FIELD,
12861 Self::SUGGESTED_GAS_PRICE_FIELD,
12862 ];
12863 }
12864 impl SimulateTransactionResponse {
12865 pub fn path_builder() -> SimulateTransactionResponseFieldPathBuilder {
12866 SimulateTransactionResponseFieldPathBuilder::new()
12867 }
12868 }
12869 pub struct SimulateTransactionResponseFieldPathBuilder {
12870 path: Vec<&'static str>,
12871 }
12872 impl SimulateTransactionResponseFieldPathBuilder {
12873 #[allow(clippy::new_without_default)]
12874 pub fn new() -> Self {
12875 Self { path: Default::default() }
12876 }
12877 #[doc(hidden)]
12878 pub fn new_with_base(base: Vec<&'static str>) -> Self {
12879 Self { path: base }
12880 }
12881 pub fn finish(self) -> String {
12882 self.path.join(".")
12883 }
12884 pub fn transaction(mut self) -> ExecutedTransactionFieldPathBuilder {
12885 self.path.push(SimulateTransactionResponse::TRANSACTION_FIELD.name);
12886 ExecutedTransactionFieldPathBuilder::new_with_base(self.path)
12887 }
12888 pub fn command_outputs(mut self) -> CommandResultFieldPathBuilder {
12889 self.path.push(SimulateTransactionResponse::COMMAND_OUTPUTS_FIELD.name);
12890 CommandResultFieldPathBuilder::new_with_base(self.path)
12891 }
12892 pub fn suggested_gas_price(mut self) -> String {
12893 self.path.push(SimulateTransactionResponse::SUGGESTED_GAS_PRICE_FIELD.name);
12894 self.finish()
12895 }
12896 }
12897 impl CommandResult {
12898 pub const RETURN_VALUES_FIELD: &'static MessageField = &MessageField {
12899 name: "return_values",
12900 json_name: "returnValues",
12901 number: 1i32,
12902 message_fields: Some(CommandOutput::FIELDS),
12903 };
12904 pub const MUTATED_BY_REF_FIELD: &'static MessageField = &MessageField {
12905 name: "mutated_by_ref",
12906 json_name: "mutatedByRef",
12907 number: 2i32,
12908 message_fields: Some(CommandOutput::FIELDS),
12909 };
12910 }
12911 impl MessageFields for CommandResult {
12912 const FIELDS: &'static [&'static MessageField] = &[
12913 Self::RETURN_VALUES_FIELD,
12914 Self::MUTATED_BY_REF_FIELD,
12915 ];
12916 }
12917 impl CommandResult {
12918 pub fn path_builder() -> CommandResultFieldPathBuilder {
12919 CommandResultFieldPathBuilder::new()
12920 }
12921 }
12922 pub struct CommandResultFieldPathBuilder {
12923 path: Vec<&'static str>,
12924 }
12925 impl CommandResultFieldPathBuilder {
12926 #[allow(clippy::new_without_default)]
12927 pub fn new() -> Self {
12928 Self { path: Default::default() }
12929 }
12930 #[doc(hidden)]
12931 pub fn new_with_base(base: Vec<&'static str>) -> Self {
12932 Self { path: base }
12933 }
12934 pub fn finish(self) -> String {
12935 self.path.join(".")
12936 }
12937 pub fn return_values(mut self) -> CommandOutputFieldPathBuilder {
12938 self.path.push(CommandResult::RETURN_VALUES_FIELD.name);
12939 CommandOutputFieldPathBuilder::new_with_base(self.path)
12940 }
12941 pub fn mutated_by_ref(mut self) -> CommandOutputFieldPathBuilder {
12942 self.path.push(CommandResult::MUTATED_BY_REF_FIELD.name);
12943 CommandOutputFieldPathBuilder::new_with_base(self.path)
12944 }
12945 }
12946 impl CommandOutput {
12947 pub const ARGUMENT_FIELD: &'static MessageField = &MessageField {
12948 name: "argument",
12949 json_name: "argument",
12950 number: 1i32,
12951 message_fields: Some(Argument::FIELDS),
12952 };
12953 pub const VALUE_FIELD: &'static MessageField = &MessageField {
12954 name: "value",
12955 json_name: "value",
12956 number: 2i32,
12957 message_fields: Some(Bcs::FIELDS),
12958 };
12959 pub const JSON_FIELD: &'static MessageField = &MessageField {
12960 name: "json",
12961 json_name: "json",
12962 number: 3i32,
12963 message_fields: None,
12964 };
12965 }
12966 impl MessageFields for CommandOutput {
12967 const FIELDS: &'static [&'static MessageField] = &[
12968 Self::ARGUMENT_FIELD,
12969 Self::VALUE_FIELD,
12970 Self::JSON_FIELD,
12971 ];
12972 }
12973 impl CommandOutput {
12974 pub fn path_builder() -> CommandOutputFieldPathBuilder {
12975 CommandOutputFieldPathBuilder::new()
12976 }
12977 }
12978 pub struct CommandOutputFieldPathBuilder {
12979 path: Vec<&'static str>,
12980 }
12981 impl CommandOutputFieldPathBuilder {
12982 #[allow(clippy::new_without_default)]
12983 pub fn new() -> Self {
12984 Self { path: Default::default() }
12985 }
12986 #[doc(hidden)]
12987 pub fn new_with_base(base: Vec<&'static str>) -> Self {
12988 Self { path: base }
12989 }
12990 pub fn finish(self) -> String {
12991 self.path.join(".")
12992 }
12993 pub fn argument(mut self) -> ArgumentFieldPathBuilder {
12994 self.path.push(CommandOutput::ARGUMENT_FIELD.name);
12995 ArgumentFieldPathBuilder::new_with_base(self.path)
12996 }
12997 pub fn value(mut self) -> BcsFieldPathBuilder {
12998 self.path.push(CommandOutput::VALUE_FIELD.name);
12999 BcsFieldPathBuilder::new_with_base(self.path)
13000 }
13001 pub fn json(mut self) -> String {
13002 self.path.push(CommandOutput::JSON_FIELD.name);
13003 self.finish()
13004 }
13005 }
13006}