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 TransactionFilter {
7 pub const TERMS_FIELD: &'static MessageField = &MessageField {
8 name: "terms",
9 json_name: "terms",
10 number: 1i32,
11 message_fields: Some(TransactionTerm::FIELDS),
12 };
13 }
14 impl MessageFields for TransactionFilter {
15 const FIELDS: &'static [&'static MessageField] = &[Self::TERMS_FIELD];
16 }
17 impl TransactionFilter {
18 pub fn path_builder() -> TransactionFilterFieldPathBuilder {
19 TransactionFilterFieldPathBuilder::new()
20 }
21 }
22 pub struct TransactionFilterFieldPathBuilder {
23 path: Vec<&'static str>,
24 }
25 impl TransactionFilterFieldPathBuilder {
26 #[allow(clippy::new_without_default)]
27 pub fn new() -> Self {
28 Self { path: Default::default() }
29 }
30 #[doc(hidden)]
31 pub fn new_with_base(base: Vec<&'static str>) -> Self {
32 Self { path: base }
33 }
34 pub fn finish(self) -> String {
35 self.path.join(".")
36 }
37 pub fn terms(mut self) -> TransactionTermFieldPathBuilder {
38 self.path.push(TransactionFilter::TERMS_FIELD.name);
39 TransactionTermFieldPathBuilder::new_with_base(self.path)
40 }
41 }
42 impl TransactionTerm {
43 pub const LITERALS_FIELD: &'static MessageField = &MessageField {
44 name: "literals",
45 json_name: "literals",
46 number: 1i32,
47 message_fields: Some(TransactionLiteral::FIELDS),
48 };
49 }
50 impl MessageFields for TransactionTerm {
51 const FIELDS: &'static [&'static MessageField] = &[Self::LITERALS_FIELD];
52 }
53 impl TransactionTerm {
54 pub fn path_builder() -> TransactionTermFieldPathBuilder {
55 TransactionTermFieldPathBuilder::new()
56 }
57 }
58 pub struct TransactionTermFieldPathBuilder {
59 path: Vec<&'static str>,
60 }
61 impl TransactionTermFieldPathBuilder {
62 #[allow(clippy::new_without_default)]
63 pub fn new() -> Self {
64 Self { path: Default::default() }
65 }
66 #[doc(hidden)]
67 pub fn new_with_base(base: Vec<&'static str>) -> Self {
68 Self { path: base }
69 }
70 pub fn finish(self) -> String {
71 self.path.join(".")
72 }
73 pub fn literals(mut self) -> TransactionLiteralFieldPathBuilder {
74 self.path.push(TransactionTerm::LITERALS_FIELD.name);
75 TransactionLiteralFieldPathBuilder::new_with_base(self.path)
76 }
77 }
78 impl TransactionLiteral {
79 pub const INCLUDE_FIELD: &'static MessageField = &MessageField {
80 name: "include",
81 json_name: "include",
82 number: 1i32,
83 message_fields: Some(TransactionPredicate::FIELDS),
84 };
85 pub const EXCLUDE_FIELD: &'static MessageField = &MessageField {
86 name: "exclude",
87 json_name: "exclude",
88 number: 2i32,
89 message_fields: Some(TransactionPredicate::FIELDS),
90 };
91 }
92 impl MessageFields for TransactionLiteral {
93 const FIELDS: &'static [&'static MessageField] = &[
94 Self::INCLUDE_FIELD,
95 Self::EXCLUDE_FIELD,
96 ];
97 }
98 impl TransactionLiteral {
99 pub fn path_builder() -> TransactionLiteralFieldPathBuilder {
100 TransactionLiteralFieldPathBuilder::new()
101 }
102 }
103 pub struct TransactionLiteralFieldPathBuilder {
104 path: Vec<&'static str>,
105 }
106 impl TransactionLiteralFieldPathBuilder {
107 #[allow(clippy::new_without_default)]
108 pub fn new() -> Self {
109 Self { path: Default::default() }
110 }
111 #[doc(hidden)]
112 pub fn new_with_base(base: Vec<&'static str>) -> Self {
113 Self { path: base }
114 }
115 pub fn finish(self) -> String {
116 self.path.join(".")
117 }
118 pub fn include(mut self) -> TransactionPredicateFieldPathBuilder {
119 self.path.push(TransactionLiteral::INCLUDE_FIELD.name);
120 TransactionPredicateFieldPathBuilder::new_with_base(self.path)
121 }
122 pub fn exclude(mut self) -> TransactionPredicateFieldPathBuilder {
123 self.path.push(TransactionLiteral::EXCLUDE_FIELD.name);
124 TransactionPredicateFieldPathBuilder::new_with_base(self.path)
125 }
126 }
127 impl TransactionPredicate {
128 pub const SENDER_FIELD: &'static MessageField = &MessageField {
129 name: "sender",
130 json_name: "sender",
131 number: 1i32,
132 message_fields: Some(SenderFilter::FIELDS),
133 };
134 pub const AFFECTED_ADDRESS_FIELD: &'static MessageField = &MessageField {
135 name: "affected_address",
136 json_name: "affectedAddress",
137 number: 2i32,
138 message_fields: Some(AffectedAddressFilter::FIELDS),
139 };
140 pub const AFFECTED_OBJECT_FIELD: &'static MessageField = &MessageField {
141 name: "affected_object",
142 json_name: "affectedObject",
143 number: 3i32,
144 message_fields: Some(AffectedObjectFilter::FIELDS),
145 };
146 pub const MOVE_CALL_FIELD: &'static MessageField = &MessageField {
147 name: "move_call",
148 json_name: "moveCall",
149 number: 4i32,
150 message_fields: Some(MoveCallFilter::FIELDS),
151 };
152 pub const EMIT_MODULE_FIELD: &'static MessageField = &MessageField {
153 name: "emit_module",
154 json_name: "emitModule",
155 number: 5i32,
156 message_fields: Some(EmitModuleFilter::FIELDS),
157 };
158 pub const EVENT_TYPE_FIELD: &'static MessageField = &MessageField {
159 name: "event_type",
160 json_name: "eventType",
161 number: 6i32,
162 message_fields: Some(EventTypeFilter::FIELDS),
163 };
164 pub const EVENT_STREAM_HEAD_FIELD: &'static MessageField = &MessageField {
165 name: "event_stream_head",
166 json_name: "eventStreamHead",
167 number: 7i32,
168 message_fields: Some(EventStreamHeadFilter::FIELDS),
169 };
170 pub const PACKAGE_WRITE_FIELD: &'static MessageField = &MessageField {
171 name: "package_write",
172 json_name: "packageWrite",
173 number: 8i32,
174 message_fields: Some(PackageWriteFilter::FIELDS),
175 };
176 }
177 impl MessageFields for TransactionPredicate {
178 const FIELDS: &'static [&'static MessageField] = &[
179 Self::SENDER_FIELD,
180 Self::AFFECTED_ADDRESS_FIELD,
181 Self::AFFECTED_OBJECT_FIELD,
182 Self::MOVE_CALL_FIELD,
183 Self::EMIT_MODULE_FIELD,
184 Self::EVENT_TYPE_FIELD,
185 Self::EVENT_STREAM_HEAD_FIELD,
186 Self::PACKAGE_WRITE_FIELD,
187 ];
188 }
189 impl TransactionPredicate {
190 pub fn path_builder() -> TransactionPredicateFieldPathBuilder {
191 TransactionPredicateFieldPathBuilder::new()
192 }
193 }
194 pub struct TransactionPredicateFieldPathBuilder {
195 path: Vec<&'static str>,
196 }
197 impl TransactionPredicateFieldPathBuilder {
198 #[allow(clippy::new_without_default)]
199 pub fn new() -> Self {
200 Self { path: Default::default() }
201 }
202 #[doc(hidden)]
203 pub fn new_with_base(base: Vec<&'static str>) -> Self {
204 Self { path: base }
205 }
206 pub fn finish(self) -> String {
207 self.path.join(".")
208 }
209 pub fn sender(mut self) -> SenderFilterFieldPathBuilder {
210 self.path.push(TransactionPredicate::SENDER_FIELD.name);
211 SenderFilterFieldPathBuilder::new_with_base(self.path)
212 }
213 pub fn affected_address(mut self) -> AffectedAddressFilterFieldPathBuilder {
214 self.path.push(TransactionPredicate::AFFECTED_ADDRESS_FIELD.name);
215 AffectedAddressFilterFieldPathBuilder::new_with_base(self.path)
216 }
217 pub fn affected_object(mut self) -> AffectedObjectFilterFieldPathBuilder {
218 self.path.push(TransactionPredicate::AFFECTED_OBJECT_FIELD.name);
219 AffectedObjectFilterFieldPathBuilder::new_with_base(self.path)
220 }
221 pub fn move_call(mut self) -> MoveCallFilterFieldPathBuilder {
222 self.path.push(TransactionPredicate::MOVE_CALL_FIELD.name);
223 MoveCallFilterFieldPathBuilder::new_with_base(self.path)
224 }
225 pub fn emit_module(mut self) -> EmitModuleFilterFieldPathBuilder {
226 self.path.push(TransactionPredicate::EMIT_MODULE_FIELD.name);
227 EmitModuleFilterFieldPathBuilder::new_with_base(self.path)
228 }
229 pub fn event_type(mut self) -> EventTypeFilterFieldPathBuilder {
230 self.path.push(TransactionPredicate::EVENT_TYPE_FIELD.name);
231 EventTypeFilterFieldPathBuilder::new_with_base(self.path)
232 }
233 pub fn event_stream_head(mut self) -> EventStreamHeadFilterFieldPathBuilder {
234 self.path.push(TransactionPredicate::EVENT_STREAM_HEAD_FIELD.name);
235 EventStreamHeadFilterFieldPathBuilder::new_with_base(self.path)
236 }
237 pub fn package_write(mut self) -> PackageWriteFilterFieldPathBuilder {
238 self.path.push(TransactionPredicate::PACKAGE_WRITE_FIELD.name);
239 PackageWriteFilterFieldPathBuilder::new_with_base(self.path)
240 }
241 }
242 impl EventFilter {
243 pub const TERMS_FIELD: &'static MessageField = &MessageField {
244 name: "terms",
245 json_name: "terms",
246 number: 1i32,
247 message_fields: Some(EventTerm::FIELDS),
248 };
249 }
250 impl MessageFields for EventFilter {
251 const FIELDS: &'static [&'static MessageField] = &[Self::TERMS_FIELD];
252 }
253 impl EventFilter {
254 pub fn path_builder() -> EventFilterFieldPathBuilder {
255 EventFilterFieldPathBuilder::new()
256 }
257 }
258 pub struct EventFilterFieldPathBuilder {
259 path: Vec<&'static str>,
260 }
261 impl EventFilterFieldPathBuilder {
262 #[allow(clippy::new_without_default)]
263 pub fn new() -> Self {
264 Self { path: Default::default() }
265 }
266 #[doc(hidden)]
267 pub fn new_with_base(base: Vec<&'static str>) -> Self {
268 Self { path: base }
269 }
270 pub fn finish(self) -> String {
271 self.path.join(".")
272 }
273 pub fn terms(mut self) -> EventTermFieldPathBuilder {
274 self.path.push(EventFilter::TERMS_FIELD.name);
275 EventTermFieldPathBuilder::new_with_base(self.path)
276 }
277 }
278 impl EventTerm {
279 pub const LITERALS_FIELD: &'static MessageField = &MessageField {
280 name: "literals",
281 json_name: "literals",
282 number: 1i32,
283 message_fields: Some(EventLiteral::FIELDS),
284 };
285 }
286 impl MessageFields for EventTerm {
287 const FIELDS: &'static [&'static MessageField] = &[Self::LITERALS_FIELD];
288 }
289 impl EventTerm {
290 pub fn path_builder() -> EventTermFieldPathBuilder {
291 EventTermFieldPathBuilder::new()
292 }
293 }
294 pub struct EventTermFieldPathBuilder {
295 path: Vec<&'static str>,
296 }
297 impl EventTermFieldPathBuilder {
298 #[allow(clippy::new_without_default)]
299 pub fn new() -> Self {
300 Self { path: Default::default() }
301 }
302 #[doc(hidden)]
303 pub fn new_with_base(base: Vec<&'static str>) -> Self {
304 Self { path: base }
305 }
306 pub fn finish(self) -> String {
307 self.path.join(".")
308 }
309 pub fn literals(mut self) -> EventLiteralFieldPathBuilder {
310 self.path.push(EventTerm::LITERALS_FIELD.name);
311 EventLiteralFieldPathBuilder::new_with_base(self.path)
312 }
313 }
314 impl EventLiteral {
315 pub const INCLUDE_FIELD: &'static MessageField = &MessageField {
316 name: "include",
317 json_name: "include",
318 number: 1i32,
319 message_fields: Some(EventPredicate::FIELDS),
320 };
321 pub const EXCLUDE_FIELD: &'static MessageField = &MessageField {
322 name: "exclude",
323 json_name: "exclude",
324 number: 2i32,
325 message_fields: Some(EventPredicate::FIELDS),
326 };
327 }
328 impl MessageFields for EventLiteral {
329 const FIELDS: &'static [&'static MessageField] = &[
330 Self::INCLUDE_FIELD,
331 Self::EXCLUDE_FIELD,
332 ];
333 }
334 impl EventLiteral {
335 pub fn path_builder() -> EventLiteralFieldPathBuilder {
336 EventLiteralFieldPathBuilder::new()
337 }
338 }
339 pub struct EventLiteralFieldPathBuilder {
340 path: Vec<&'static str>,
341 }
342 impl EventLiteralFieldPathBuilder {
343 #[allow(clippy::new_without_default)]
344 pub fn new() -> Self {
345 Self { path: Default::default() }
346 }
347 #[doc(hidden)]
348 pub fn new_with_base(base: Vec<&'static str>) -> Self {
349 Self { path: base }
350 }
351 pub fn finish(self) -> String {
352 self.path.join(".")
353 }
354 pub fn include(mut self) -> EventPredicateFieldPathBuilder {
355 self.path.push(EventLiteral::INCLUDE_FIELD.name);
356 EventPredicateFieldPathBuilder::new_with_base(self.path)
357 }
358 pub fn exclude(mut self) -> EventPredicateFieldPathBuilder {
359 self.path.push(EventLiteral::EXCLUDE_FIELD.name);
360 EventPredicateFieldPathBuilder::new_with_base(self.path)
361 }
362 }
363 impl EventPredicate {
364 pub const SENDER_FIELD: &'static MessageField = &MessageField {
365 name: "sender",
366 json_name: "sender",
367 number: 1i32,
368 message_fields: Some(SenderFilter::FIELDS),
369 };
370 pub const EMIT_MODULE_FIELD: &'static MessageField = &MessageField {
371 name: "emit_module",
372 json_name: "emitModule",
373 number: 2i32,
374 message_fields: Some(EmitModuleFilter::FIELDS),
375 };
376 pub const EVENT_TYPE_FIELD: &'static MessageField = &MessageField {
377 name: "event_type",
378 json_name: "eventType",
379 number: 3i32,
380 message_fields: Some(EventTypeFilter::FIELDS),
381 };
382 pub const EVENT_STREAM_HEAD_FIELD: &'static MessageField = &MessageField {
383 name: "event_stream_head",
384 json_name: "eventStreamHead",
385 number: 4i32,
386 message_fields: Some(EventStreamHeadFilter::FIELDS),
387 };
388 }
389 impl MessageFields for EventPredicate {
390 const FIELDS: &'static [&'static MessageField] = &[
391 Self::SENDER_FIELD,
392 Self::EMIT_MODULE_FIELD,
393 Self::EVENT_TYPE_FIELD,
394 Self::EVENT_STREAM_HEAD_FIELD,
395 ];
396 }
397 impl EventPredicate {
398 pub fn path_builder() -> EventPredicateFieldPathBuilder {
399 EventPredicateFieldPathBuilder::new()
400 }
401 }
402 pub struct EventPredicateFieldPathBuilder {
403 path: Vec<&'static str>,
404 }
405 impl EventPredicateFieldPathBuilder {
406 #[allow(clippy::new_without_default)]
407 pub fn new() -> Self {
408 Self { path: Default::default() }
409 }
410 #[doc(hidden)]
411 pub fn new_with_base(base: Vec<&'static str>) -> Self {
412 Self { path: base }
413 }
414 pub fn finish(self) -> String {
415 self.path.join(".")
416 }
417 pub fn sender(mut self) -> SenderFilterFieldPathBuilder {
418 self.path.push(EventPredicate::SENDER_FIELD.name);
419 SenderFilterFieldPathBuilder::new_with_base(self.path)
420 }
421 pub fn emit_module(mut self) -> EmitModuleFilterFieldPathBuilder {
422 self.path.push(EventPredicate::EMIT_MODULE_FIELD.name);
423 EmitModuleFilterFieldPathBuilder::new_with_base(self.path)
424 }
425 pub fn event_type(mut self) -> EventTypeFilterFieldPathBuilder {
426 self.path.push(EventPredicate::EVENT_TYPE_FIELD.name);
427 EventTypeFilterFieldPathBuilder::new_with_base(self.path)
428 }
429 pub fn event_stream_head(mut self) -> EventStreamHeadFilterFieldPathBuilder {
430 self.path.push(EventPredicate::EVENT_STREAM_HEAD_FIELD.name);
431 EventStreamHeadFilterFieldPathBuilder::new_with_base(self.path)
432 }
433 }
434 impl SenderFilter {
435 pub const ADDRESS_FIELD: &'static MessageField = &MessageField {
436 name: "address",
437 json_name: "address",
438 number: 1i32,
439 message_fields: None,
440 };
441 }
442 impl MessageFields for SenderFilter {
443 const FIELDS: &'static [&'static MessageField] = &[Self::ADDRESS_FIELD];
444 }
445 impl SenderFilter {
446 pub fn path_builder() -> SenderFilterFieldPathBuilder {
447 SenderFilterFieldPathBuilder::new()
448 }
449 }
450 pub struct SenderFilterFieldPathBuilder {
451 path: Vec<&'static str>,
452 }
453 impl SenderFilterFieldPathBuilder {
454 #[allow(clippy::new_without_default)]
455 pub fn new() -> Self {
456 Self { path: Default::default() }
457 }
458 #[doc(hidden)]
459 pub fn new_with_base(base: Vec<&'static str>) -> Self {
460 Self { path: base }
461 }
462 pub fn finish(self) -> String {
463 self.path.join(".")
464 }
465 pub fn address(mut self) -> String {
466 self.path.push(SenderFilter::ADDRESS_FIELD.name);
467 self.finish()
468 }
469 }
470 impl AffectedAddressFilter {
471 pub const ADDRESS_FIELD: &'static MessageField = &MessageField {
472 name: "address",
473 json_name: "address",
474 number: 1i32,
475 message_fields: None,
476 };
477 }
478 impl MessageFields for AffectedAddressFilter {
479 const FIELDS: &'static [&'static MessageField] = &[Self::ADDRESS_FIELD];
480 }
481 impl AffectedAddressFilter {
482 pub fn path_builder() -> AffectedAddressFilterFieldPathBuilder {
483 AffectedAddressFilterFieldPathBuilder::new()
484 }
485 }
486 pub struct AffectedAddressFilterFieldPathBuilder {
487 path: Vec<&'static str>,
488 }
489 impl AffectedAddressFilterFieldPathBuilder {
490 #[allow(clippy::new_without_default)]
491 pub fn new() -> Self {
492 Self { path: Default::default() }
493 }
494 #[doc(hidden)]
495 pub fn new_with_base(base: Vec<&'static str>) -> Self {
496 Self { path: base }
497 }
498 pub fn finish(self) -> String {
499 self.path.join(".")
500 }
501 pub fn address(mut self) -> String {
502 self.path.push(AffectedAddressFilter::ADDRESS_FIELD.name);
503 self.finish()
504 }
505 }
506 impl AffectedObjectFilter {
507 pub const OBJECT_ID_FIELD: &'static MessageField = &MessageField {
508 name: "object_id",
509 json_name: "objectId",
510 number: 1i32,
511 message_fields: None,
512 };
513 }
514 impl MessageFields for AffectedObjectFilter {
515 const FIELDS: &'static [&'static MessageField] = &[Self::OBJECT_ID_FIELD];
516 }
517 impl AffectedObjectFilter {
518 pub fn path_builder() -> AffectedObjectFilterFieldPathBuilder {
519 AffectedObjectFilterFieldPathBuilder::new()
520 }
521 }
522 pub struct AffectedObjectFilterFieldPathBuilder {
523 path: Vec<&'static str>,
524 }
525 impl AffectedObjectFilterFieldPathBuilder {
526 #[allow(clippy::new_without_default)]
527 pub fn new() -> Self {
528 Self { path: Default::default() }
529 }
530 #[doc(hidden)]
531 pub fn new_with_base(base: Vec<&'static str>) -> Self {
532 Self { path: base }
533 }
534 pub fn finish(self) -> String {
535 self.path.join(".")
536 }
537 pub fn object_id(mut self) -> String {
538 self.path.push(AffectedObjectFilter::OBJECT_ID_FIELD.name);
539 self.finish()
540 }
541 }
542 impl MoveCallFilter {
543 pub const FUNCTION_FIELD: &'static MessageField = &MessageField {
544 name: "function",
545 json_name: "function",
546 number: 1i32,
547 message_fields: None,
548 };
549 }
550 impl MessageFields for MoveCallFilter {
551 const FIELDS: &'static [&'static MessageField] = &[Self::FUNCTION_FIELD];
552 }
553 impl MoveCallFilter {
554 pub fn path_builder() -> MoveCallFilterFieldPathBuilder {
555 MoveCallFilterFieldPathBuilder::new()
556 }
557 }
558 pub struct MoveCallFilterFieldPathBuilder {
559 path: Vec<&'static str>,
560 }
561 impl MoveCallFilterFieldPathBuilder {
562 #[allow(clippy::new_without_default)]
563 pub fn new() -> Self {
564 Self { path: Default::default() }
565 }
566 #[doc(hidden)]
567 pub fn new_with_base(base: Vec<&'static str>) -> Self {
568 Self { path: base }
569 }
570 pub fn finish(self) -> String {
571 self.path.join(".")
572 }
573 pub fn function(mut self) -> String {
574 self.path.push(MoveCallFilter::FUNCTION_FIELD.name);
575 self.finish()
576 }
577 }
578 impl EmitModuleFilter {
579 pub const MODULE_FIELD: &'static MessageField = &MessageField {
580 name: "module",
581 json_name: "module",
582 number: 1i32,
583 message_fields: None,
584 };
585 }
586 impl MessageFields for EmitModuleFilter {
587 const FIELDS: &'static [&'static MessageField] = &[Self::MODULE_FIELD];
588 }
589 impl EmitModuleFilter {
590 pub fn path_builder() -> EmitModuleFilterFieldPathBuilder {
591 EmitModuleFilterFieldPathBuilder::new()
592 }
593 }
594 pub struct EmitModuleFilterFieldPathBuilder {
595 path: Vec<&'static str>,
596 }
597 impl EmitModuleFilterFieldPathBuilder {
598 #[allow(clippy::new_without_default)]
599 pub fn new() -> Self {
600 Self { path: Default::default() }
601 }
602 #[doc(hidden)]
603 pub fn new_with_base(base: Vec<&'static str>) -> Self {
604 Self { path: base }
605 }
606 pub fn finish(self) -> String {
607 self.path.join(".")
608 }
609 pub fn module(mut self) -> String {
610 self.path.push(EmitModuleFilter::MODULE_FIELD.name);
611 self.finish()
612 }
613 }
614 impl EventTypeFilter {
615 pub const TYPE_FIELD: &'static MessageField = &MessageField {
616 name: "type",
617 json_name: "type",
618 number: 1i32,
619 message_fields: None,
620 };
621 }
622 impl MessageFields for EventTypeFilter {
623 const FIELDS: &'static [&'static MessageField] = &[Self::TYPE_FIELD];
624 }
625 impl EventTypeFilter {
626 pub fn path_builder() -> EventTypeFilterFieldPathBuilder {
627 EventTypeFilterFieldPathBuilder::new()
628 }
629 }
630 pub struct EventTypeFilterFieldPathBuilder {
631 path: Vec<&'static str>,
632 }
633 impl EventTypeFilterFieldPathBuilder {
634 #[allow(clippy::new_without_default)]
635 pub fn new() -> Self {
636 Self { path: Default::default() }
637 }
638 #[doc(hidden)]
639 pub fn new_with_base(base: Vec<&'static str>) -> Self {
640 Self { path: base }
641 }
642 pub fn finish(self) -> String {
643 self.path.join(".")
644 }
645 pub fn r#type(mut self) -> String {
646 self.path.push(EventTypeFilter::TYPE_FIELD.name);
647 self.finish()
648 }
649 }
650 impl EventStreamHeadFilter {
651 pub const STREAM_ID_FIELD: &'static MessageField = &MessageField {
652 name: "stream_id",
653 json_name: "streamId",
654 number: 1i32,
655 message_fields: None,
656 };
657 }
658 impl MessageFields for EventStreamHeadFilter {
659 const FIELDS: &'static [&'static MessageField] = &[Self::STREAM_ID_FIELD];
660 }
661 impl EventStreamHeadFilter {
662 pub fn path_builder() -> EventStreamHeadFilterFieldPathBuilder {
663 EventStreamHeadFilterFieldPathBuilder::new()
664 }
665 }
666 pub struct EventStreamHeadFilterFieldPathBuilder {
667 path: Vec<&'static str>,
668 }
669 impl EventStreamHeadFilterFieldPathBuilder {
670 #[allow(clippy::new_without_default)]
671 pub fn new() -> Self {
672 Self { path: Default::default() }
673 }
674 #[doc(hidden)]
675 pub fn new_with_base(base: Vec<&'static str>) -> Self {
676 Self { path: base }
677 }
678 pub fn finish(self) -> String {
679 self.path.join(".")
680 }
681 pub fn stream_id(mut self) -> String {
682 self.path.push(EventStreamHeadFilter::STREAM_ID_FIELD.name);
683 self.finish()
684 }
685 }
686 impl PackageWriteFilter {}
687 impl MessageFields for PackageWriteFilter {
688 const FIELDS: &'static [&'static MessageField] = &[];
689 }
690 impl PackageWriteFilter {
691 pub fn path_builder() -> PackageWriteFilterFieldPathBuilder {
692 PackageWriteFilterFieldPathBuilder::new()
693 }
694 }
695 pub struct PackageWriteFilterFieldPathBuilder {
696 path: Vec<&'static str>,
697 }
698 impl PackageWriteFilterFieldPathBuilder {
699 #[allow(clippy::new_without_default)]
700 pub fn new() -> Self {
701 Self { path: Default::default() }
702 }
703 #[doc(hidden)]
704 pub fn new_with_base(base: Vec<&'static str>) -> Self {
705 Self { path: base }
706 }
707 pub fn finish(self) -> String {
708 self.path.join(".")
709 }
710 }
711 impl ListCheckpointsRequest {
712 pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
713 name: "read_mask",
714 json_name: "readMask",
715 number: 1i32,
716 message_fields: None,
717 };
718 pub const START_CHECKPOINT_FIELD: &'static MessageField = &MessageField {
719 name: "start_checkpoint",
720 json_name: "startCheckpoint",
721 number: 2i32,
722 message_fields: None,
723 };
724 pub const END_CHECKPOINT_FIELD: &'static MessageField = &MessageField {
725 name: "end_checkpoint",
726 json_name: "endCheckpoint",
727 number: 3i32,
728 message_fields: None,
729 };
730 pub const FILTER_FIELD: &'static MessageField = &MessageField {
731 name: "filter",
732 json_name: "filter",
733 number: 4i32,
734 message_fields: Some(TransactionFilter::FIELDS),
735 };
736 pub const OPTIONS_FIELD: &'static MessageField = &MessageField {
737 name: "options",
738 json_name: "options",
739 number: 5i32,
740 message_fields: Some(QueryOptions::FIELDS),
741 };
742 }
743 impl MessageFields for ListCheckpointsRequest {
744 const FIELDS: &'static [&'static MessageField] = &[
745 Self::READ_MASK_FIELD,
746 Self::START_CHECKPOINT_FIELD,
747 Self::END_CHECKPOINT_FIELD,
748 Self::FILTER_FIELD,
749 Self::OPTIONS_FIELD,
750 ];
751 }
752 impl ListCheckpointsRequest {
753 pub fn path_builder() -> ListCheckpointsRequestFieldPathBuilder {
754 ListCheckpointsRequestFieldPathBuilder::new()
755 }
756 }
757 pub struct ListCheckpointsRequestFieldPathBuilder {
758 path: Vec<&'static str>,
759 }
760 impl ListCheckpointsRequestFieldPathBuilder {
761 #[allow(clippy::new_without_default)]
762 pub fn new() -> Self {
763 Self { path: Default::default() }
764 }
765 #[doc(hidden)]
766 pub fn new_with_base(base: Vec<&'static str>) -> Self {
767 Self { path: base }
768 }
769 pub fn finish(self) -> String {
770 self.path.join(".")
771 }
772 pub fn read_mask(mut self) -> String {
773 self.path.push(ListCheckpointsRequest::READ_MASK_FIELD.name);
774 self.finish()
775 }
776 pub fn start_checkpoint(mut self) -> String {
777 self.path.push(ListCheckpointsRequest::START_CHECKPOINT_FIELD.name);
778 self.finish()
779 }
780 pub fn end_checkpoint(mut self) -> String {
781 self.path.push(ListCheckpointsRequest::END_CHECKPOINT_FIELD.name);
782 self.finish()
783 }
784 pub fn filter(mut self) -> TransactionFilterFieldPathBuilder {
785 self.path.push(ListCheckpointsRequest::FILTER_FIELD.name);
786 TransactionFilterFieldPathBuilder::new_with_base(self.path)
787 }
788 pub fn options(mut self) -> QueryOptionsFieldPathBuilder {
789 self.path.push(ListCheckpointsRequest::OPTIONS_FIELD.name);
790 QueryOptionsFieldPathBuilder::new_with_base(self.path)
791 }
792 }
793 impl CheckpointItem {
794 pub const CHECKPOINT_FIELD: &'static MessageField = &MessageField {
795 name: "checkpoint",
796 json_name: "checkpoint",
797 number: 1i32,
798 message_fields: Some(Checkpoint::FIELDS),
799 };
800 pub const WATERMARK_FIELD: &'static MessageField = &MessageField {
801 name: "watermark",
802 json_name: "watermark",
803 number: 2i32,
804 message_fields: Some(Watermark::FIELDS),
805 };
806 }
807 impl MessageFields for CheckpointItem {
808 const FIELDS: &'static [&'static MessageField] = &[
809 Self::CHECKPOINT_FIELD,
810 Self::WATERMARK_FIELD,
811 ];
812 }
813 impl CheckpointItem {
814 pub fn path_builder() -> CheckpointItemFieldPathBuilder {
815 CheckpointItemFieldPathBuilder::new()
816 }
817 }
818 pub struct CheckpointItemFieldPathBuilder {
819 path: Vec<&'static str>,
820 }
821 impl CheckpointItemFieldPathBuilder {
822 #[allow(clippy::new_without_default)]
823 pub fn new() -> Self {
824 Self { path: Default::default() }
825 }
826 #[doc(hidden)]
827 pub fn new_with_base(base: Vec<&'static str>) -> Self {
828 Self { path: base }
829 }
830 pub fn finish(self) -> String {
831 self.path.join(".")
832 }
833 pub fn checkpoint(mut self) -> CheckpointFieldPathBuilder {
834 self.path.push(CheckpointItem::CHECKPOINT_FIELD.name);
835 CheckpointFieldPathBuilder::new_with_base(self.path)
836 }
837 pub fn watermark(mut self) -> WatermarkFieldPathBuilder {
838 self.path.push(CheckpointItem::WATERMARK_FIELD.name);
839 WatermarkFieldPathBuilder::new_with_base(self.path)
840 }
841 }
842 impl ListCheckpointsResponse {
843 pub const ITEM_FIELD: &'static MessageField = &MessageField {
844 name: "item",
845 json_name: "item",
846 number: 1i32,
847 message_fields: Some(CheckpointItem::FIELDS),
848 };
849 pub const WATERMARK_FIELD: &'static MessageField = &MessageField {
850 name: "watermark",
851 json_name: "watermark",
852 number: 2i32,
853 message_fields: Some(Watermark::FIELDS),
854 };
855 pub const END_FIELD: &'static MessageField = &MessageField {
856 name: "end",
857 json_name: "end",
858 number: 3i32,
859 message_fields: Some(QueryEnd::FIELDS),
860 };
861 }
862 impl MessageFields for ListCheckpointsResponse {
863 const FIELDS: &'static [&'static MessageField] = &[
864 Self::ITEM_FIELD,
865 Self::WATERMARK_FIELD,
866 Self::END_FIELD,
867 ];
868 }
869 impl ListCheckpointsResponse {
870 pub fn path_builder() -> ListCheckpointsResponseFieldPathBuilder {
871 ListCheckpointsResponseFieldPathBuilder::new()
872 }
873 }
874 pub struct ListCheckpointsResponseFieldPathBuilder {
875 path: Vec<&'static str>,
876 }
877 impl ListCheckpointsResponseFieldPathBuilder {
878 #[allow(clippy::new_without_default)]
879 pub fn new() -> Self {
880 Self { path: Default::default() }
881 }
882 #[doc(hidden)]
883 pub fn new_with_base(base: Vec<&'static str>) -> Self {
884 Self { path: base }
885 }
886 pub fn finish(self) -> String {
887 self.path.join(".")
888 }
889 pub fn item(mut self) -> CheckpointItemFieldPathBuilder {
890 self.path.push(ListCheckpointsResponse::ITEM_FIELD.name);
891 CheckpointItemFieldPathBuilder::new_with_base(self.path)
892 }
893 pub fn watermark(mut self) -> WatermarkFieldPathBuilder {
894 self.path.push(ListCheckpointsResponse::WATERMARK_FIELD.name);
895 WatermarkFieldPathBuilder::new_with_base(self.path)
896 }
897 pub fn end(mut self) -> QueryEndFieldPathBuilder {
898 self.path.push(ListCheckpointsResponse::END_FIELD.name);
899 QueryEndFieldPathBuilder::new_with_base(self.path)
900 }
901 }
902 impl ListTransactionsRequest {
903 pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
904 name: "read_mask",
905 json_name: "readMask",
906 number: 1i32,
907 message_fields: None,
908 };
909 pub const START_CHECKPOINT_FIELD: &'static MessageField = &MessageField {
910 name: "start_checkpoint",
911 json_name: "startCheckpoint",
912 number: 2i32,
913 message_fields: None,
914 };
915 pub const END_CHECKPOINT_FIELD: &'static MessageField = &MessageField {
916 name: "end_checkpoint",
917 json_name: "endCheckpoint",
918 number: 3i32,
919 message_fields: None,
920 };
921 pub const FILTER_FIELD: &'static MessageField = &MessageField {
922 name: "filter",
923 json_name: "filter",
924 number: 4i32,
925 message_fields: Some(TransactionFilter::FIELDS),
926 };
927 pub const OPTIONS_FIELD: &'static MessageField = &MessageField {
928 name: "options",
929 json_name: "options",
930 number: 5i32,
931 message_fields: Some(QueryOptions::FIELDS),
932 };
933 }
934 impl MessageFields for ListTransactionsRequest {
935 const FIELDS: &'static [&'static MessageField] = &[
936 Self::READ_MASK_FIELD,
937 Self::START_CHECKPOINT_FIELD,
938 Self::END_CHECKPOINT_FIELD,
939 Self::FILTER_FIELD,
940 Self::OPTIONS_FIELD,
941 ];
942 }
943 impl ListTransactionsRequest {
944 pub fn path_builder() -> ListTransactionsRequestFieldPathBuilder {
945 ListTransactionsRequestFieldPathBuilder::new()
946 }
947 }
948 pub struct ListTransactionsRequestFieldPathBuilder {
949 path: Vec<&'static str>,
950 }
951 impl ListTransactionsRequestFieldPathBuilder {
952 #[allow(clippy::new_without_default)]
953 pub fn new() -> Self {
954 Self { path: Default::default() }
955 }
956 #[doc(hidden)]
957 pub fn new_with_base(base: Vec<&'static str>) -> Self {
958 Self { path: base }
959 }
960 pub fn finish(self) -> String {
961 self.path.join(".")
962 }
963 pub fn read_mask(mut self) -> String {
964 self.path.push(ListTransactionsRequest::READ_MASK_FIELD.name);
965 self.finish()
966 }
967 pub fn start_checkpoint(mut self) -> String {
968 self.path.push(ListTransactionsRequest::START_CHECKPOINT_FIELD.name);
969 self.finish()
970 }
971 pub fn end_checkpoint(mut self) -> String {
972 self.path.push(ListTransactionsRequest::END_CHECKPOINT_FIELD.name);
973 self.finish()
974 }
975 pub fn filter(mut self) -> TransactionFilterFieldPathBuilder {
976 self.path.push(ListTransactionsRequest::FILTER_FIELD.name);
977 TransactionFilterFieldPathBuilder::new_with_base(self.path)
978 }
979 pub fn options(mut self) -> QueryOptionsFieldPathBuilder {
980 self.path.push(ListTransactionsRequest::OPTIONS_FIELD.name);
981 QueryOptionsFieldPathBuilder::new_with_base(self.path)
982 }
983 }
984 impl TransactionItem {
985 pub const TRANSACTION_FIELD: &'static MessageField = &MessageField {
986 name: "transaction",
987 json_name: "transaction",
988 number: 1i32,
989 message_fields: Some(ExecutedTransaction::FIELDS),
990 };
991 pub const WATERMARK_FIELD: &'static MessageField = &MessageField {
992 name: "watermark",
993 json_name: "watermark",
994 number: 2i32,
995 message_fields: Some(Watermark::FIELDS),
996 };
997 pub const TRANSACTION_OFFSET_FIELD: &'static MessageField = &MessageField {
998 name: "transaction_offset",
999 json_name: "transactionOffset",
1000 number: 3i32,
1001 message_fields: None,
1002 };
1003 }
1004 impl MessageFields for TransactionItem {
1005 const FIELDS: &'static [&'static MessageField] = &[
1006 Self::TRANSACTION_FIELD,
1007 Self::WATERMARK_FIELD,
1008 Self::TRANSACTION_OFFSET_FIELD,
1009 ];
1010 }
1011 impl TransactionItem {
1012 pub fn path_builder() -> TransactionItemFieldPathBuilder {
1013 TransactionItemFieldPathBuilder::new()
1014 }
1015 }
1016 pub struct TransactionItemFieldPathBuilder {
1017 path: Vec<&'static str>,
1018 }
1019 impl TransactionItemFieldPathBuilder {
1020 #[allow(clippy::new_without_default)]
1021 pub fn new() -> Self {
1022 Self { path: Default::default() }
1023 }
1024 #[doc(hidden)]
1025 pub fn new_with_base(base: Vec<&'static str>) -> Self {
1026 Self { path: base }
1027 }
1028 pub fn finish(self) -> String {
1029 self.path.join(".")
1030 }
1031 pub fn transaction(mut self) -> ExecutedTransactionFieldPathBuilder {
1032 self.path.push(TransactionItem::TRANSACTION_FIELD.name);
1033 ExecutedTransactionFieldPathBuilder::new_with_base(self.path)
1034 }
1035 pub fn watermark(mut self) -> WatermarkFieldPathBuilder {
1036 self.path.push(TransactionItem::WATERMARK_FIELD.name);
1037 WatermarkFieldPathBuilder::new_with_base(self.path)
1038 }
1039 pub fn transaction_offset(mut self) -> String {
1040 self.path.push(TransactionItem::TRANSACTION_OFFSET_FIELD.name);
1041 self.finish()
1042 }
1043 }
1044 impl ListTransactionsResponse {
1045 pub const ITEM_FIELD: &'static MessageField = &MessageField {
1046 name: "item",
1047 json_name: "item",
1048 number: 1i32,
1049 message_fields: Some(TransactionItem::FIELDS),
1050 };
1051 pub const WATERMARK_FIELD: &'static MessageField = &MessageField {
1052 name: "watermark",
1053 json_name: "watermark",
1054 number: 2i32,
1055 message_fields: Some(Watermark::FIELDS),
1056 };
1057 pub const END_FIELD: &'static MessageField = &MessageField {
1058 name: "end",
1059 json_name: "end",
1060 number: 3i32,
1061 message_fields: Some(QueryEnd::FIELDS),
1062 };
1063 }
1064 impl MessageFields for ListTransactionsResponse {
1065 const FIELDS: &'static [&'static MessageField] = &[
1066 Self::ITEM_FIELD,
1067 Self::WATERMARK_FIELD,
1068 Self::END_FIELD,
1069 ];
1070 }
1071 impl ListTransactionsResponse {
1072 pub fn path_builder() -> ListTransactionsResponseFieldPathBuilder {
1073 ListTransactionsResponseFieldPathBuilder::new()
1074 }
1075 }
1076 pub struct ListTransactionsResponseFieldPathBuilder {
1077 path: Vec<&'static str>,
1078 }
1079 impl ListTransactionsResponseFieldPathBuilder {
1080 #[allow(clippy::new_without_default)]
1081 pub fn new() -> Self {
1082 Self { path: Default::default() }
1083 }
1084 #[doc(hidden)]
1085 pub fn new_with_base(base: Vec<&'static str>) -> Self {
1086 Self { path: base }
1087 }
1088 pub fn finish(self) -> String {
1089 self.path.join(".")
1090 }
1091 pub fn item(mut self) -> TransactionItemFieldPathBuilder {
1092 self.path.push(ListTransactionsResponse::ITEM_FIELD.name);
1093 TransactionItemFieldPathBuilder::new_with_base(self.path)
1094 }
1095 pub fn watermark(mut self) -> WatermarkFieldPathBuilder {
1096 self.path.push(ListTransactionsResponse::WATERMARK_FIELD.name);
1097 WatermarkFieldPathBuilder::new_with_base(self.path)
1098 }
1099 pub fn end(mut self) -> QueryEndFieldPathBuilder {
1100 self.path.push(ListTransactionsResponse::END_FIELD.name);
1101 QueryEndFieldPathBuilder::new_with_base(self.path)
1102 }
1103 }
1104 impl ListEventsRequest {
1105 pub const READ_MASK_FIELD: &'static MessageField = &MessageField {
1106 name: "read_mask",
1107 json_name: "readMask",
1108 number: 1i32,
1109 message_fields: None,
1110 };
1111 pub const START_CHECKPOINT_FIELD: &'static MessageField = &MessageField {
1112 name: "start_checkpoint",
1113 json_name: "startCheckpoint",
1114 number: 2i32,
1115 message_fields: None,
1116 };
1117 pub const END_CHECKPOINT_FIELD: &'static MessageField = &MessageField {
1118 name: "end_checkpoint",
1119 json_name: "endCheckpoint",
1120 number: 3i32,
1121 message_fields: None,
1122 };
1123 pub const FILTER_FIELD: &'static MessageField = &MessageField {
1124 name: "filter",
1125 json_name: "filter",
1126 number: 4i32,
1127 message_fields: Some(EventFilter::FIELDS),
1128 };
1129 pub const OPTIONS_FIELD: &'static MessageField = &MessageField {
1130 name: "options",
1131 json_name: "options",
1132 number: 5i32,
1133 message_fields: Some(QueryOptions::FIELDS),
1134 };
1135 }
1136 impl MessageFields for ListEventsRequest {
1137 const FIELDS: &'static [&'static MessageField] = &[
1138 Self::READ_MASK_FIELD,
1139 Self::START_CHECKPOINT_FIELD,
1140 Self::END_CHECKPOINT_FIELD,
1141 Self::FILTER_FIELD,
1142 Self::OPTIONS_FIELD,
1143 ];
1144 }
1145 impl ListEventsRequest {
1146 pub fn path_builder() -> ListEventsRequestFieldPathBuilder {
1147 ListEventsRequestFieldPathBuilder::new()
1148 }
1149 }
1150 pub struct ListEventsRequestFieldPathBuilder {
1151 path: Vec<&'static str>,
1152 }
1153 impl ListEventsRequestFieldPathBuilder {
1154 #[allow(clippy::new_without_default)]
1155 pub fn new() -> Self {
1156 Self { path: Default::default() }
1157 }
1158 #[doc(hidden)]
1159 pub fn new_with_base(base: Vec<&'static str>) -> Self {
1160 Self { path: base }
1161 }
1162 pub fn finish(self) -> String {
1163 self.path.join(".")
1164 }
1165 pub fn read_mask(mut self) -> String {
1166 self.path.push(ListEventsRequest::READ_MASK_FIELD.name);
1167 self.finish()
1168 }
1169 pub fn start_checkpoint(mut self) -> String {
1170 self.path.push(ListEventsRequest::START_CHECKPOINT_FIELD.name);
1171 self.finish()
1172 }
1173 pub fn end_checkpoint(mut self) -> String {
1174 self.path.push(ListEventsRequest::END_CHECKPOINT_FIELD.name);
1175 self.finish()
1176 }
1177 pub fn filter(mut self) -> EventFilterFieldPathBuilder {
1178 self.path.push(ListEventsRequest::FILTER_FIELD.name);
1179 EventFilterFieldPathBuilder::new_with_base(self.path)
1180 }
1181 pub fn options(mut self) -> QueryOptionsFieldPathBuilder {
1182 self.path.push(ListEventsRequest::OPTIONS_FIELD.name);
1183 QueryOptionsFieldPathBuilder::new_with_base(self.path)
1184 }
1185 }
1186 impl EventItem {
1187 pub const WATERMARK_FIELD: &'static MessageField = &MessageField {
1188 name: "watermark",
1189 json_name: "watermark",
1190 number: 1i32,
1191 message_fields: Some(Watermark::FIELDS),
1192 };
1193 pub const CHECKPOINT_FIELD: &'static MessageField = &MessageField {
1194 name: "checkpoint",
1195 json_name: "checkpoint",
1196 number: 2i32,
1197 message_fields: None,
1198 };
1199 pub const EVENT_INDEX_FIELD: &'static MessageField = &MessageField {
1200 name: "event_index",
1201 json_name: "eventIndex",
1202 number: 3i32,
1203 message_fields: None,
1204 };
1205 pub const TRANSACTION_DIGEST_FIELD: &'static MessageField = &MessageField {
1206 name: "transaction_digest",
1207 json_name: "transactionDigest",
1208 number: 4i32,
1209 message_fields: None,
1210 };
1211 pub const EVENT_FIELD: &'static MessageField = &MessageField {
1212 name: "event",
1213 json_name: "event",
1214 number: 5i32,
1215 message_fields: Some(Event::FIELDS),
1216 };
1217 pub const TRANSACTION_OFFSET_FIELD: &'static MessageField = &MessageField {
1218 name: "transaction_offset",
1219 json_name: "transactionOffset",
1220 number: 6i32,
1221 message_fields: None,
1222 };
1223 }
1224 impl MessageFields for EventItem {
1225 const FIELDS: &'static [&'static MessageField] = &[
1226 Self::WATERMARK_FIELD,
1227 Self::CHECKPOINT_FIELD,
1228 Self::EVENT_INDEX_FIELD,
1229 Self::TRANSACTION_DIGEST_FIELD,
1230 Self::EVENT_FIELD,
1231 Self::TRANSACTION_OFFSET_FIELD,
1232 ];
1233 }
1234 impl EventItem {
1235 pub fn path_builder() -> EventItemFieldPathBuilder {
1236 EventItemFieldPathBuilder::new()
1237 }
1238 }
1239 pub struct EventItemFieldPathBuilder {
1240 path: Vec<&'static str>,
1241 }
1242 impl EventItemFieldPathBuilder {
1243 #[allow(clippy::new_without_default)]
1244 pub fn new() -> Self {
1245 Self { path: Default::default() }
1246 }
1247 #[doc(hidden)]
1248 pub fn new_with_base(base: Vec<&'static str>) -> Self {
1249 Self { path: base }
1250 }
1251 pub fn finish(self) -> String {
1252 self.path.join(".")
1253 }
1254 pub fn watermark(mut self) -> WatermarkFieldPathBuilder {
1255 self.path.push(EventItem::WATERMARK_FIELD.name);
1256 WatermarkFieldPathBuilder::new_with_base(self.path)
1257 }
1258 pub fn checkpoint(mut self) -> String {
1259 self.path.push(EventItem::CHECKPOINT_FIELD.name);
1260 self.finish()
1261 }
1262 pub fn event_index(mut self) -> String {
1263 self.path.push(EventItem::EVENT_INDEX_FIELD.name);
1264 self.finish()
1265 }
1266 pub fn transaction_digest(mut self) -> String {
1267 self.path.push(EventItem::TRANSACTION_DIGEST_FIELD.name);
1268 self.finish()
1269 }
1270 pub fn event(mut self) -> EventFieldPathBuilder {
1271 self.path.push(EventItem::EVENT_FIELD.name);
1272 EventFieldPathBuilder::new_with_base(self.path)
1273 }
1274 pub fn transaction_offset(mut self) -> String {
1275 self.path.push(EventItem::TRANSACTION_OFFSET_FIELD.name);
1276 self.finish()
1277 }
1278 }
1279 impl ListEventsResponse {
1280 pub const ITEM_FIELD: &'static MessageField = &MessageField {
1281 name: "item",
1282 json_name: "item",
1283 number: 1i32,
1284 message_fields: Some(EventItem::FIELDS),
1285 };
1286 pub const WATERMARK_FIELD: &'static MessageField = &MessageField {
1287 name: "watermark",
1288 json_name: "watermark",
1289 number: 2i32,
1290 message_fields: Some(Watermark::FIELDS),
1291 };
1292 pub const END_FIELD: &'static MessageField = &MessageField {
1293 name: "end",
1294 json_name: "end",
1295 number: 3i32,
1296 message_fields: Some(QueryEnd::FIELDS),
1297 };
1298 }
1299 impl MessageFields for ListEventsResponse {
1300 const FIELDS: &'static [&'static MessageField] = &[
1301 Self::ITEM_FIELD,
1302 Self::WATERMARK_FIELD,
1303 Self::END_FIELD,
1304 ];
1305 }
1306 impl ListEventsResponse {
1307 pub fn path_builder() -> ListEventsResponseFieldPathBuilder {
1308 ListEventsResponseFieldPathBuilder::new()
1309 }
1310 }
1311 pub struct ListEventsResponseFieldPathBuilder {
1312 path: Vec<&'static str>,
1313 }
1314 impl ListEventsResponseFieldPathBuilder {
1315 #[allow(clippy::new_without_default)]
1316 pub fn new() -> Self {
1317 Self { path: Default::default() }
1318 }
1319 #[doc(hidden)]
1320 pub fn new_with_base(base: Vec<&'static str>) -> Self {
1321 Self { path: base }
1322 }
1323 pub fn finish(self) -> String {
1324 self.path.join(".")
1325 }
1326 pub fn item(mut self) -> EventItemFieldPathBuilder {
1327 self.path.push(ListEventsResponse::ITEM_FIELD.name);
1328 EventItemFieldPathBuilder::new_with_base(self.path)
1329 }
1330 pub fn watermark(mut self) -> WatermarkFieldPathBuilder {
1331 self.path.push(ListEventsResponse::WATERMARK_FIELD.name);
1332 WatermarkFieldPathBuilder::new_with_base(self.path)
1333 }
1334 pub fn end(mut self) -> QueryEndFieldPathBuilder {
1335 self.path.push(ListEventsResponse::END_FIELD.name);
1336 QueryEndFieldPathBuilder::new_with_base(self.path)
1337 }
1338 }
1339 impl MerkleNode {
1340 pub const EMPTY_FIELD: &'static MessageField = &MessageField {
1341 name: "empty",
1342 json_name: "empty",
1343 number: 1i32,
1344 message_fields: None,
1345 };
1346 pub const DIGEST_FIELD: &'static MessageField = &MessageField {
1347 name: "digest",
1348 json_name: "digest",
1349 number: 2i32,
1350 message_fields: None,
1351 };
1352 }
1353 impl MessageFields for MerkleNode {
1354 const FIELDS: &'static [&'static MessageField] = &[
1355 Self::EMPTY_FIELD,
1356 Self::DIGEST_FIELD,
1357 ];
1358 }
1359 impl MerkleNode {
1360 pub fn path_builder() -> MerkleNodeFieldPathBuilder {
1361 MerkleNodeFieldPathBuilder::new()
1362 }
1363 }
1364 pub struct MerkleNodeFieldPathBuilder {
1365 path: Vec<&'static str>,
1366 }
1367 impl MerkleNodeFieldPathBuilder {
1368 #[allow(clippy::new_without_default)]
1369 pub fn new() -> Self {
1370 Self { path: Default::default() }
1371 }
1372 #[doc(hidden)]
1373 pub fn new_with_base(base: Vec<&'static str>) -> Self {
1374 Self { path: base }
1375 }
1376 pub fn finish(self) -> String {
1377 self.path.join(".")
1378 }
1379 pub fn empty(mut self) -> String {
1380 self.path.push(MerkleNode::EMPTY_FIELD.name);
1381 self.finish()
1382 }
1383 pub fn digest(mut self) -> String {
1384 self.path.push(MerkleNode::DIGEST_FIELD.name);
1385 self.finish()
1386 }
1387 }
1388 impl MerkleProof {
1389 pub const PATH_FIELD: &'static MessageField = &MessageField {
1390 name: "path",
1391 json_name: "path",
1392 number: 1i32,
1393 message_fields: Some(MerkleNode::FIELDS),
1394 };
1395 }
1396 impl MessageFields for MerkleProof {
1397 const FIELDS: &'static [&'static MessageField] = &[Self::PATH_FIELD];
1398 }
1399 impl MerkleProof {
1400 pub fn path_builder() -> MerkleProofFieldPathBuilder {
1401 MerkleProofFieldPathBuilder::new()
1402 }
1403 }
1404 pub struct MerkleProofFieldPathBuilder {
1405 path: Vec<&'static str>,
1406 }
1407 impl MerkleProofFieldPathBuilder {
1408 #[allow(clippy::new_without_default)]
1409 pub fn new() -> Self {
1410 Self { path: Default::default() }
1411 }
1412 #[doc(hidden)]
1413 pub fn new_with_base(base: Vec<&'static str>) -> Self {
1414 Self { path: base }
1415 }
1416 pub fn finish(self) -> String {
1417 self.path.join(".")
1418 }
1419 pub fn path(mut self) -> MerkleNodeFieldPathBuilder {
1420 self.path.push(MerkleProof::PATH_FIELD.name);
1421 MerkleNodeFieldPathBuilder::new_with_base(self.path)
1422 }
1423 }
1424 impl MerkleNonInclusionProof {
1425 pub const INDEX_FIELD: &'static MessageField = &MessageField {
1426 name: "index",
1427 json_name: "index",
1428 number: 1i32,
1429 message_fields: None,
1430 };
1431 pub const LEFT_LEAF_FIELD: &'static MessageField = &MessageField {
1432 name: "left_leaf",
1433 json_name: "leftLeaf",
1434 number: 2i32,
1435 message_fields: Some(MerkleNeighbourLeaf::FIELDS),
1436 };
1437 pub const RIGHT_LEAF_FIELD: &'static MessageField = &MessageField {
1438 name: "right_leaf",
1439 json_name: "rightLeaf",
1440 number: 3i32,
1441 message_fields: Some(MerkleNeighbourLeaf::FIELDS),
1442 };
1443 }
1444 impl MessageFields for MerkleNonInclusionProof {
1445 const FIELDS: &'static [&'static MessageField] = &[
1446 Self::INDEX_FIELD,
1447 Self::LEFT_LEAF_FIELD,
1448 Self::RIGHT_LEAF_FIELD,
1449 ];
1450 }
1451 impl MerkleNonInclusionProof {
1452 pub fn path_builder() -> MerkleNonInclusionProofFieldPathBuilder {
1453 MerkleNonInclusionProofFieldPathBuilder::new()
1454 }
1455 }
1456 pub struct MerkleNonInclusionProofFieldPathBuilder {
1457 path: Vec<&'static str>,
1458 }
1459 impl MerkleNonInclusionProofFieldPathBuilder {
1460 #[allow(clippy::new_without_default)]
1461 pub fn new() -> Self {
1462 Self { path: Default::default() }
1463 }
1464 #[doc(hidden)]
1465 pub fn new_with_base(base: Vec<&'static str>) -> Self {
1466 Self { path: base }
1467 }
1468 pub fn finish(self) -> String {
1469 self.path.join(".")
1470 }
1471 pub fn index(mut self) -> String {
1472 self.path.push(MerkleNonInclusionProof::INDEX_FIELD.name);
1473 self.finish()
1474 }
1475 pub fn left_leaf(mut self) -> MerkleNeighbourLeafFieldPathBuilder {
1476 self.path.push(MerkleNonInclusionProof::LEFT_LEAF_FIELD.name);
1477 MerkleNeighbourLeafFieldPathBuilder::new_with_base(self.path)
1478 }
1479 pub fn right_leaf(mut self) -> MerkleNeighbourLeafFieldPathBuilder {
1480 self.path.push(MerkleNonInclusionProof::RIGHT_LEAF_FIELD.name);
1481 MerkleNeighbourLeafFieldPathBuilder::new_with_base(self.path)
1482 }
1483 }
1484 impl MerkleNeighbourLeaf {
1485 pub const LEAF_FIELD: &'static MessageField = &MessageField {
1486 name: "leaf",
1487 json_name: "leaf",
1488 number: 1i32,
1489 message_fields: Some(ObjectReference::FIELDS),
1490 };
1491 pub const MERKLE_PROOF_FIELD: &'static MessageField = &MessageField {
1492 name: "merkle_proof",
1493 json_name: "merkleProof",
1494 number: 2i32,
1495 message_fields: Some(MerkleProof::FIELDS),
1496 };
1497 }
1498 impl MessageFields for MerkleNeighbourLeaf {
1499 const FIELDS: &'static [&'static MessageField] = &[
1500 Self::LEAF_FIELD,
1501 Self::MERKLE_PROOF_FIELD,
1502 ];
1503 }
1504 impl MerkleNeighbourLeaf {
1505 pub fn path_builder() -> MerkleNeighbourLeafFieldPathBuilder {
1506 MerkleNeighbourLeafFieldPathBuilder::new()
1507 }
1508 }
1509 pub struct MerkleNeighbourLeafFieldPathBuilder {
1510 path: Vec<&'static str>,
1511 }
1512 impl MerkleNeighbourLeafFieldPathBuilder {
1513 #[allow(clippy::new_without_default)]
1514 pub fn new() -> Self {
1515 Self { path: Default::default() }
1516 }
1517 #[doc(hidden)]
1518 pub fn new_with_base(base: Vec<&'static str>) -> Self {
1519 Self { path: base }
1520 }
1521 pub fn finish(self) -> String {
1522 self.path.join(".")
1523 }
1524 pub fn leaf(mut self) -> ObjectReferenceFieldPathBuilder {
1525 self.path.push(MerkleNeighbourLeaf::LEAF_FIELD.name);
1526 ObjectReferenceFieldPathBuilder::new_with_base(self.path)
1527 }
1528 pub fn merkle_proof(mut self) -> MerkleProofFieldPathBuilder {
1529 self.path.push(MerkleNeighbourLeaf::MERKLE_PROOF_FIELD.name);
1530 MerkleProofFieldPathBuilder::new_with_base(self.path)
1531 }
1532 }
1533 impl OcsInclusionProof {
1534 pub const OBJECT_REF_FIELD: &'static MessageField = &MessageField {
1535 name: "object_ref",
1536 json_name: "objectRef",
1537 number: 1i32,
1538 message_fields: Some(ObjectReference::FIELDS),
1539 };
1540 pub const MERKLE_PROOF_FIELD: &'static MessageField = &MessageField {
1541 name: "merkle_proof",
1542 json_name: "merkleProof",
1543 number: 2i32,
1544 message_fields: Some(MerkleProof::FIELDS),
1545 };
1546 pub const LEAF_INDEX_FIELD: &'static MessageField = &MessageField {
1547 name: "leaf_index",
1548 json_name: "leafIndex",
1549 number: 3i32,
1550 message_fields: None,
1551 };
1552 pub const TREE_ROOT_FIELD: &'static MessageField = &MessageField {
1553 name: "tree_root",
1554 json_name: "treeRoot",
1555 number: 4i32,
1556 message_fields: None,
1557 };
1558 pub const OBJECT_DATA_FIELD: &'static MessageField = &MessageField {
1559 name: "object_data",
1560 json_name: "objectData",
1561 number: 5i32,
1562 message_fields: None,
1563 };
1564 }
1565 impl MessageFields for OcsInclusionProof {
1566 const FIELDS: &'static [&'static MessageField] = &[
1567 Self::OBJECT_REF_FIELD,
1568 Self::MERKLE_PROOF_FIELD,
1569 Self::LEAF_INDEX_FIELD,
1570 Self::TREE_ROOT_FIELD,
1571 Self::OBJECT_DATA_FIELD,
1572 ];
1573 }
1574 impl OcsInclusionProof {
1575 pub fn path_builder() -> OcsInclusionProofFieldPathBuilder {
1576 OcsInclusionProofFieldPathBuilder::new()
1577 }
1578 }
1579 pub struct OcsInclusionProofFieldPathBuilder {
1580 path: Vec<&'static str>,
1581 }
1582 impl OcsInclusionProofFieldPathBuilder {
1583 #[allow(clippy::new_without_default)]
1584 pub fn new() -> Self {
1585 Self { path: Default::default() }
1586 }
1587 #[doc(hidden)]
1588 pub fn new_with_base(base: Vec<&'static str>) -> Self {
1589 Self { path: base }
1590 }
1591 pub fn finish(self) -> String {
1592 self.path.join(".")
1593 }
1594 pub fn object_ref(mut self) -> ObjectReferenceFieldPathBuilder {
1595 self.path.push(OcsInclusionProof::OBJECT_REF_FIELD.name);
1596 ObjectReferenceFieldPathBuilder::new_with_base(self.path)
1597 }
1598 pub fn merkle_proof(mut self) -> MerkleProofFieldPathBuilder {
1599 self.path.push(OcsInclusionProof::MERKLE_PROOF_FIELD.name);
1600 MerkleProofFieldPathBuilder::new_with_base(self.path)
1601 }
1602 pub fn leaf_index(mut self) -> String {
1603 self.path.push(OcsInclusionProof::LEAF_INDEX_FIELD.name);
1604 self.finish()
1605 }
1606 pub fn tree_root(mut self) -> String {
1607 self.path.push(OcsInclusionProof::TREE_ROOT_FIELD.name);
1608 self.finish()
1609 }
1610 pub fn object_data(mut self) -> String {
1611 self.path.push(OcsInclusionProof::OBJECT_DATA_FIELD.name);
1612 self.finish()
1613 }
1614 }
1615 impl OcsNonInclusionProof {
1616 pub const NON_INCLUSION_PROOF_FIELD: &'static MessageField = &MessageField {
1617 name: "non_inclusion_proof",
1618 json_name: "nonInclusionProof",
1619 number: 1i32,
1620 message_fields: Some(MerkleNonInclusionProof::FIELDS),
1621 };
1622 pub const TREE_ROOT_FIELD: &'static MessageField = &MessageField {
1623 name: "tree_root",
1624 json_name: "treeRoot",
1625 number: 2i32,
1626 message_fields: None,
1627 };
1628 }
1629 impl MessageFields for OcsNonInclusionProof {
1630 const FIELDS: &'static [&'static MessageField] = &[
1631 Self::NON_INCLUSION_PROOF_FIELD,
1632 Self::TREE_ROOT_FIELD,
1633 ];
1634 }
1635 impl OcsNonInclusionProof {
1636 pub fn path_builder() -> OcsNonInclusionProofFieldPathBuilder {
1637 OcsNonInclusionProofFieldPathBuilder::new()
1638 }
1639 }
1640 pub struct OcsNonInclusionProofFieldPathBuilder {
1641 path: Vec<&'static str>,
1642 }
1643 impl OcsNonInclusionProofFieldPathBuilder {
1644 #[allow(clippy::new_without_default)]
1645 pub fn new() -> Self {
1646 Self { path: Default::default() }
1647 }
1648 #[doc(hidden)]
1649 pub fn new_with_base(base: Vec<&'static str>) -> Self {
1650 Self { path: base }
1651 }
1652 pub fn finish(self) -> String {
1653 self.path.join(".")
1654 }
1655 pub fn non_inclusion_proof(mut self) -> MerkleNonInclusionProofFieldPathBuilder {
1656 self.path.push(OcsNonInclusionProof::NON_INCLUSION_PROOF_FIELD.name);
1657 MerkleNonInclusionProofFieldPathBuilder::new_with_base(self.path)
1658 }
1659 pub fn tree_root(mut self) -> String {
1660 self.path.push(OcsNonInclusionProof::TREE_ROOT_FIELD.name);
1661 self.finish()
1662 }
1663 }
1664 impl GetCheckpointObjectProofRequest {
1665 pub const OBJECT_ID_FIELD: &'static MessageField = &MessageField {
1666 name: "object_id",
1667 json_name: "objectId",
1668 number: 1i32,
1669 message_fields: None,
1670 };
1671 pub const CHECKPOINT_FIELD: &'static MessageField = &MessageField {
1672 name: "checkpoint",
1673 json_name: "checkpoint",
1674 number: 2i32,
1675 message_fields: None,
1676 };
1677 }
1678 impl MessageFields for GetCheckpointObjectProofRequest {
1679 const FIELDS: &'static [&'static MessageField] = &[
1680 Self::OBJECT_ID_FIELD,
1681 Self::CHECKPOINT_FIELD,
1682 ];
1683 }
1684 impl GetCheckpointObjectProofRequest {
1685 pub fn path_builder() -> GetCheckpointObjectProofRequestFieldPathBuilder {
1686 GetCheckpointObjectProofRequestFieldPathBuilder::new()
1687 }
1688 }
1689 pub struct GetCheckpointObjectProofRequestFieldPathBuilder {
1690 path: Vec<&'static str>,
1691 }
1692 impl GetCheckpointObjectProofRequestFieldPathBuilder {
1693 #[allow(clippy::new_without_default)]
1694 pub fn new() -> Self {
1695 Self { path: Default::default() }
1696 }
1697 #[doc(hidden)]
1698 pub fn new_with_base(base: Vec<&'static str>) -> Self {
1699 Self { path: base }
1700 }
1701 pub fn finish(self) -> String {
1702 self.path.join(".")
1703 }
1704 pub fn object_id(mut self) -> String {
1705 self.path.push(GetCheckpointObjectProofRequest::OBJECT_ID_FIELD.name);
1706 self.finish()
1707 }
1708 pub fn checkpoint(mut self) -> String {
1709 self.path.push(GetCheckpointObjectProofRequest::CHECKPOINT_FIELD.name);
1710 self.finish()
1711 }
1712 }
1713 impl GetCheckpointObjectProofResponse {
1714 pub const CHECKPOINT_SUMMARY_FIELD: &'static MessageField = &MessageField {
1715 name: "checkpoint_summary",
1716 json_name: "checkpointSummary",
1717 number: 1i32,
1718 message_fields: None,
1719 };
1720 pub const INCLUSION_FIELD: &'static MessageField = &MessageField {
1721 name: "inclusion",
1722 json_name: "inclusion",
1723 number: 2i32,
1724 message_fields: Some(OcsInclusionProof::FIELDS),
1725 };
1726 pub const NON_INCLUSION_FIELD: &'static MessageField = &MessageField {
1727 name: "non_inclusion",
1728 json_name: "nonInclusion",
1729 number: 3i32,
1730 message_fields: Some(OcsNonInclusionProof::FIELDS),
1731 };
1732 }
1733 impl MessageFields for GetCheckpointObjectProofResponse {
1734 const FIELDS: &'static [&'static MessageField] = &[
1735 Self::CHECKPOINT_SUMMARY_FIELD,
1736 Self::INCLUSION_FIELD,
1737 Self::NON_INCLUSION_FIELD,
1738 ];
1739 }
1740 impl GetCheckpointObjectProofResponse {
1741 pub fn path_builder() -> GetCheckpointObjectProofResponseFieldPathBuilder {
1742 GetCheckpointObjectProofResponseFieldPathBuilder::new()
1743 }
1744 }
1745 pub struct GetCheckpointObjectProofResponseFieldPathBuilder {
1746 path: Vec<&'static str>,
1747 }
1748 impl GetCheckpointObjectProofResponseFieldPathBuilder {
1749 #[allow(clippy::new_without_default)]
1750 pub fn new() -> Self {
1751 Self { path: Default::default() }
1752 }
1753 #[doc(hidden)]
1754 pub fn new_with_base(base: Vec<&'static str>) -> Self {
1755 Self { path: base }
1756 }
1757 pub fn finish(self) -> String {
1758 self.path.join(".")
1759 }
1760 pub fn checkpoint_summary(mut self) -> String {
1761 self.path
1762 .push(GetCheckpointObjectProofResponse::CHECKPOINT_SUMMARY_FIELD.name);
1763 self.finish()
1764 }
1765 pub fn inclusion(mut self) -> OcsInclusionProofFieldPathBuilder {
1766 self.path.push(GetCheckpointObjectProofResponse::INCLUSION_FIELD.name);
1767 OcsInclusionProofFieldPathBuilder::new_with_base(self.path)
1768 }
1769 pub fn non_inclusion(mut self) -> OcsNonInclusionProofFieldPathBuilder {
1770 self.path.push(GetCheckpointObjectProofResponse::NON_INCLUSION_FIELD.name);
1771 OcsNonInclusionProofFieldPathBuilder::new_with_base(self.path)
1772 }
1773 }
1774 impl QueryOptions {
1775 pub const LIMIT_ITEMS_FIELD: &'static MessageField = &MessageField {
1776 name: "limit_items",
1777 json_name: "limitItems",
1778 number: 1i32,
1779 message_fields: None,
1780 };
1781 pub const AFTER_FIELD: &'static MessageField = &MessageField {
1782 name: "after",
1783 json_name: "after",
1784 number: 2i32,
1785 message_fields: None,
1786 };
1787 pub const BEFORE_FIELD: &'static MessageField = &MessageField {
1788 name: "before",
1789 json_name: "before",
1790 number: 3i32,
1791 message_fields: None,
1792 };
1793 pub const ORDERING_FIELD: &'static MessageField = &MessageField {
1794 name: "ordering",
1795 json_name: "ordering",
1796 number: 4i32,
1797 message_fields: None,
1798 };
1799 }
1800 impl MessageFields for QueryOptions {
1801 const FIELDS: &'static [&'static MessageField] = &[
1802 Self::LIMIT_ITEMS_FIELD,
1803 Self::AFTER_FIELD,
1804 Self::BEFORE_FIELD,
1805 Self::ORDERING_FIELD,
1806 ];
1807 }
1808 impl QueryOptions {
1809 pub fn path_builder() -> QueryOptionsFieldPathBuilder {
1810 QueryOptionsFieldPathBuilder::new()
1811 }
1812 }
1813 pub struct QueryOptionsFieldPathBuilder {
1814 path: Vec<&'static str>,
1815 }
1816 impl QueryOptionsFieldPathBuilder {
1817 #[allow(clippy::new_without_default)]
1818 pub fn new() -> Self {
1819 Self { path: Default::default() }
1820 }
1821 #[doc(hidden)]
1822 pub fn new_with_base(base: Vec<&'static str>) -> Self {
1823 Self { path: base }
1824 }
1825 pub fn finish(self) -> String {
1826 self.path.join(".")
1827 }
1828 pub fn limit_items(mut self) -> String {
1829 self.path.push(QueryOptions::LIMIT_ITEMS_FIELD.name);
1830 self.finish()
1831 }
1832 pub fn after(mut self) -> String {
1833 self.path.push(QueryOptions::AFTER_FIELD.name);
1834 self.finish()
1835 }
1836 pub fn before(mut self) -> String {
1837 self.path.push(QueryOptions::BEFORE_FIELD.name);
1838 self.finish()
1839 }
1840 pub fn ordering(mut self) -> String {
1841 self.path.push(QueryOptions::ORDERING_FIELD.name);
1842 self.finish()
1843 }
1844 }
1845 impl Watermark {
1846 pub const CURSOR_FIELD: &'static MessageField = &MessageField {
1847 name: "cursor",
1848 json_name: "cursor",
1849 number: 1i32,
1850 message_fields: None,
1851 };
1852 pub const CHECKPOINT_HI_FIELD: &'static MessageField = &MessageField {
1853 name: "checkpoint_hi",
1854 json_name: "checkpointHi",
1855 number: 2i32,
1856 message_fields: None,
1857 };
1858 pub const CHECKPOINT_LO_FIELD: &'static MessageField = &MessageField {
1859 name: "checkpoint_lo",
1860 json_name: "checkpointLo",
1861 number: 3i32,
1862 message_fields: None,
1863 };
1864 }
1865 impl MessageFields for Watermark {
1866 const FIELDS: &'static [&'static MessageField] = &[
1867 Self::CURSOR_FIELD,
1868 Self::CHECKPOINT_HI_FIELD,
1869 Self::CHECKPOINT_LO_FIELD,
1870 ];
1871 }
1872 impl Watermark {
1873 pub fn path_builder() -> WatermarkFieldPathBuilder {
1874 WatermarkFieldPathBuilder::new()
1875 }
1876 }
1877 pub struct WatermarkFieldPathBuilder {
1878 path: Vec<&'static str>,
1879 }
1880 impl WatermarkFieldPathBuilder {
1881 #[allow(clippy::new_without_default)]
1882 pub fn new() -> Self {
1883 Self { path: Default::default() }
1884 }
1885 #[doc(hidden)]
1886 pub fn new_with_base(base: Vec<&'static str>) -> Self {
1887 Self { path: base }
1888 }
1889 pub fn finish(self) -> String {
1890 self.path.join(".")
1891 }
1892 pub fn cursor(mut self) -> String {
1893 self.path.push(Watermark::CURSOR_FIELD.name);
1894 self.finish()
1895 }
1896 pub fn checkpoint_hi(mut self) -> String {
1897 self.path.push(Watermark::CHECKPOINT_HI_FIELD.name);
1898 self.finish()
1899 }
1900 pub fn checkpoint_lo(mut self) -> String {
1901 self.path.push(Watermark::CHECKPOINT_LO_FIELD.name);
1902 self.finish()
1903 }
1904 }
1905 impl QueryEnd {
1906 pub const REASON_FIELD: &'static MessageField = &MessageField {
1907 name: "reason",
1908 json_name: "reason",
1909 number: 1i32,
1910 message_fields: None,
1911 };
1912 }
1913 impl MessageFields for QueryEnd {
1914 const FIELDS: &'static [&'static MessageField] = &[Self::REASON_FIELD];
1915 }
1916 impl QueryEnd {
1917 pub fn path_builder() -> QueryEndFieldPathBuilder {
1918 QueryEndFieldPathBuilder::new()
1919 }
1920 }
1921 pub struct QueryEndFieldPathBuilder {
1922 path: Vec<&'static str>,
1923 }
1924 impl QueryEndFieldPathBuilder {
1925 #[allow(clippy::new_without_default)]
1926 pub fn new() -> Self {
1927 Self { path: Default::default() }
1928 }
1929 #[doc(hidden)]
1930 pub fn new_with_base(base: Vec<&'static str>) -> Self {
1931 Self { path: base }
1932 }
1933 pub fn finish(self) -> String {
1934 self.path.join(".")
1935 }
1936 pub fn reason(mut self) -> String {
1937 self.path.push(QueryEnd::REASON_FIELD.name);
1938 self.finish()
1939 }
1940 }
1941}