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