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