1#![warn(clippy::all)]
3#![allow(unused_parens, unused_variables, unused_mut, unused_imports, unreachable_code)]
4
5#[derive(Debug)]
6#[repr(C)]
7pub struct CloneableCloneRequest {
8 pub request: ::fidl_next::ServerEnd<::fidl_next::fuchsia::zx::Channel, crate::Cloneable>,
9}
10
11impl ::fidl_next::Encodable for CloneableCloneRequest {
12 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireCloneableCloneRequest> = unsafe {
13 ::fidl_next::CopyOptimization::enable_if(
14 true
15
16 && <
17 ::fidl_next::ServerEnd<::fidl_next::fuchsia::zx::Channel,crate::Cloneable,
18 > as ::fidl_next::Encodable
19 >::COPY_OPTIMIZATION.is_enabled()
20
21 )
22 };
23
24 type Encoded = WireCloneableCloneRequest;
25}
26
27unsafe impl<___E> ::fidl_next::Encode<___E> for CloneableCloneRequest
28where
29 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
30
31 ___E: ::fidl_next::fuchsia::HandleEncoder,
32{
33 #[inline]
34 fn encode(
35 self,
36 encoder: &mut ___E,
37 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
38 ) -> Result<(), ::fidl_next::EncodeError> {
39 ::fidl_next::munge! {
40 let Self::Encoded {
41 request,
42
43 } = out;
44 }
45
46 ::fidl_next::Encode::encode(self.request, encoder, request)?;
47
48 Ok(())
49 }
50}
51
52impl ::fidl_next::EncodableOption for CloneableCloneRequest {
53 type EncodedOption = ::fidl_next::WireBox<'static, WireCloneableCloneRequest>;
54}
55
56unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CloneableCloneRequest
57where
58 ___E: ::fidl_next::Encoder + ?Sized,
59 CloneableCloneRequest: ::fidl_next::Encode<___E>,
60{
61 #[inline]
62 fn encode_option(
63 this: Option<Self>,
64 encoder: &mut ___E,
65 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
66 ) -> Result<(), ::fidl_next::EncodeError> {
67 if let Some(inner) = this {
68 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
69 ::fidl_next::WireBox::encode_present(out);
70 } else {
71 ::fidl_next::WireBox::encode_absent(out);
72 }
73
74 Ok(())
75 }
76}
77
78impl ::fidl_next::FromWire<WireCloneableCloneRequest> for CloneableCloneRequest {
79 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireCloneableCloneRequest, Self> = unsafe {
80 ::fidl_next::CopyOptimization::enable_if(
81 true
82
83 && <
84 ::fidl_next::ServerEnd<::fidl_next::fuchsia::zx::Channel,crate::Cloneable,
85 > as ::fidl_next::FromWire<::fidl_next::ServerEnd<::fidl_next::fuchsia::WireChannel,crate::Cloneable,
86 >>
87 >::COPY_OPTIMIZATION.is_enabled()
88
89 )
90 };
91
92 #[inline]
93 fn from_wire(wire: WireCloneableCloneRequest) -> Self {
94 Self { request: ::fidl_next::FromWire::from_wire(wire.request) }
95 }
96}
97
98#[derive(Debug)]
100#[repr(C)]
101pub struct WireCloneableCloneRequest {
102 pub request: ::fidl_next::ServerEnd<::fidl_next::fuchsia::WireChannel, crate::Cloneable>,
103}
104
105unsafe impl ::fidl_next::Wire for WireCloneableCloneRequest {
106 type Decoded<'de> = WireCloneableCloneRequest;
107
108 #[inline]
109 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
110}
111
112unsafe impl<___D> ::fidl_next::Decode<___D> for WireCloneableCloneRequest
113where
114 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
115
116 ___D: ::fidl_next::fuchsia::HandleDecoder,
117{
118 fn decode(
119 slot: ::fidl_next::Slot<'_, Self>,
120 decoder: &mut ___D,
121 ) -> Result<(), ::fidl_next::DecodeError> {
122 ::fidl_next::munge! {
123 let Self {
124 mut request,
125
126 } = slot;
127 }
128
129 ::fidl_next::Decode::decode(request.as_mut(), decoder)?;
130
131 Ok(())
132 }
133}
134
135#[doc = " Provides a means of duplicating a connection.\n\n See the composing protocol\'s documentation for a description of\n connection-scoped state, if any.\n"]
137#[derive(Debug)]
138pub struct Cloneable;
139
140pub mod cloneable {
141 pub mod prelude {
142 pub use crate::{
143 cloneable, Cloneable, CloneableClientHandler, CloneableClientSender,
144 CloneableServerHandler, CloneableServerSender,
145 };
146
147 pub use crate::CloneableCloneRequest;
148 }
149
150 pub struct Clone;
151
152 impl ::fidl_next::Method for Clone {
153 const ORDINAL: u64 = 2366825959783828089;
154
155 type Protocol = crate::Cloneable;
156
157 type Request = crate::WireCloneableCloneRequest;
158
159 type Response = ::fidl_next::Never;
160 }
161}
162
163pub trait CloneableClientSender {
165 type Transport: ::fidl_next::Transport;
166
167 fn clone<___R>(
168 &self,
169 request: ___R,
170 ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
171 where
172 ___R: ::fidl_next::Encode<
173 <Self::Transport as ::fidl_next::Transport>::SendBuffer,
174 Encoded = crate::WireCloneableCloneRequest,
175 >;
176}
177
178impl<___T> CloneableClientSender for ::fidl_next::ClientSender<___T, Cloneable>
179where
180 ___T: ::fidl_next::Transport,
181{
182 type Transport = ___T;
183
184 fn clone<___R>(
185 &self,
186 request: ___R,
187 ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
188 where
189 ___R: ::fidl_next::Encode<
190 <Self::Transport as ::fidl_next::Transport>::SendBuffer,
191 Encoded = crate::WireCloneableCloneRequest,
192 >,
193 {
194 self.as_untyped().send_one_way(2366825959783828089, request)
195 }
196}
197
198pub trait CloneableClientHandler<___T: ::fidl_next::Transport> {}
202
203impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for Cloneable
204where
205 ___T: ::fidl_next::Transport,
206 ___H: CloneableClientHandler<___T>,
207{
208 fn on_event(
209 handler: &mut ___H,
210 sender: &::fidl_next::ClientSender<___T, Self>,
211 ordinal: u64,
212 buffer: ___T::RecvBuffer,
213 ) {
214 match ordinal {
215 ordinal => {
216 sender.close();
217 }
218 }
219 }
220}
221
222pub trait CloneableServerSender {
224 type Transport: ::fidl_next::Transport;
225}
226
227impl<___T> CloneableServerSender for ::fidl_next::ServerSender<___T, Cloneable>
228where
229 ___T: ::fidl_next::Transport,
230{
231 type Transport = ___T;
232}
233
234pub trait CloneableServerHandler<___T: ::fidl_next::Transport> {
238 fn clone(
239 &mut self,
240 sender: &::fidl_next::ServerSender<___T, Cloneable>,
241
242 request: ::fidl_next::Request<___T, cloneable::Clone>,
243 );
244}
245
246impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for Cloneable
247where
248 ___T: ::fidl_next::Transport,
249 ___H: CloneableServerHandler<___T>,
250
251 <cloneable::Clone as ::fidl_next::Method>::Request:
252 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
253{
254 fn on_one_way(
255 handler: &mut ___H,
256 sender: &::fidl_next::ServerSender<___T, Self>,
257 ordinal: u64,
258 buffer: ___T::RecvBuffer,
259 ) {
260 match ordinal {
261 2366825959783828089 => match ::fidl_next::DecoderExt::decode(buffer) {
262 Ok(decoded) => handler.clone(sender, decoded),
263 Err(e) => {
264 sender.close();
265 }
266 },
267
268 ordinal => {
269 sender.close();
270 }
271 }
272 }
273
274 fn on_two_way(
275 handler: &mut ___H,
276 sender: &::fidl_next::ServerSender<___T, Self>,
277 ordinal: u64,
278 buffer: ___T::RecvBuffer,
279 responder: ::fidl_next::protocol::Responder,
280 ) {
281 match ordinal {
282 ordinal => {
283 sender.close();
284 }
285 }
286 }
287}
288
289pub type CloseableCloseResponse = ();
290
291pub type WireCloseableCloseResponse = ();
293
294#[doc = " Provides a means of synchronously closing a connection.\n"]
296#[derive(Debug)]
297pub struct Closeable;
298
299pub mod closeable {
300 pub mod prelude {
301 pub use crate::{
302 closeable, Closeable, CloseableClientHandler, CloseableClientSender,
303 CloseableServerHandler, CloseableServerSender,
304 };
305
306 pub use crate::CloseableCloseResponse;
307 }
308
309 pub struct Close;
310
311 impl ::fidl_next::Method for Close {
312 const ORDINAL: u64 = 6540867515453498750;
313
314 type Protocol = crate::Closeable;
315
316 type Request = ();
317
318 type Response = ::fidl_next::WireResult<
319 'static,
320 crate::WireCloseableCloseResponse,
321 ::fidl_next::WireI32,
322 >;
323 }
324}
325
326pub trait CloseableClientSender {
328 type Transport: ::fidl_next::Transport;
329
330 #[doc = " Terminates the connection.\n\n After calling `Close`, the client must not send any other requests.\n\n Servers, after sending the status response, should close the connection\n regardless of status and without sending an epitaph.\n\n Closing the client end of the channel should be semantically equivalent\n to calling `Close` without knowing when the close has completed or its\n status.\n"]
331 fn close(
332 &self,
333 ) -> Result<
334 ::fidl_next::ResponseFuture<'_, Self::Transport, closeable::Close>,
335 ::fidl_next::EncodeError,
336 >;
337}
338
339impl<___T> CloseableClientSender for ::fidl_next::ClientSender<___T, Closeable>
340where
341 ___T: ::fidl_next::Transport,
342{
343 type Transport = ___T;
344
345 #[doc = " Terminates the connection.\n\n After calling `Close`, the client must not send any other requests.\n\n Servers, after sending the status response, should close the connection\n regardless of status and without sending an epitaph.\n\n Closing the client end of the channel should be semantically equivalent\n to calling `Close` without knowing when the close has completed or its\n status.\n"]
346 fn close(
347 &self,
348 ) -> Result<
349 ::fidl_next::ResponseFuture<'_, Self::Transport, closeable::Close>,
350 ::fidl_next::EncodeError,
351 > {
352 self.as_untyped()
353 .send_two_way(6540867515453498750, ())
354 .map(::fidl_next::ResponseFuture::from_untyped)
355 }
356}
357
358pub trait CloseableClientHandler<___T: ::fidl_next::Transport> {}
362
363impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for Closeable
364where
365 ___T: ::fidl_next::Transport,
366 ___H: CloseableClientHandler<___T>,
367
368 <closeable::Close as ::fidl_next::Method>::Response:
369 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
370{
371 fn on_event(
372 handler: &mut ___H,
373 sender: &::fidl_next::ClientSender<___T, Self>,
374 ordinal: u64,
375 buffer: ___T::RecvBuffer,
376 ) {
377 match ordinal {
378 ordinal => {
379 sender.close();
380 }
381 }
382 }
383}
384
385pub trait CloseableServerSender {
387 type Transport: ::fidl_next::Transport;
388}
389
390impl<___T> CloseableServerSender for ::fidl_next::ServerSender<___T, Closeable>
391where
392 ___T: ::fidl_next::Transport,
393{
394 type Transport = ___T;
395}
396
397pub trait CloseableServerHandler<___T: ::fidl_next::Transport> {
401 #[doc = " Terminates the connection.\n\n After calling `Close`, the client must not send any other requests.\n\n Servers, after sending the status response, should close the connection\n regardless of status and without sending an epitaph.\n\n Closing the client end of the channel should be semantically equivalent\n to calling `Close` without knowing when the close has completed or its\n status.\n"]
402 fn close(
403 &mut self,
404 sender: &::fidl_next::ServerSender<___T, Closeable>,
405
406 responder: ::fidl_next::Responder<closeable::Close>,
407 );
408}
409
410impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for Closeable
411where
412 ___T: ::fidl_next::Transport,
413 ___H: CloseableServerHandler<___T>,
414{
415 fn on_one_way(
416 handler: &mut ___H,
417 sender: &::fidl_next::ServerSender<___T, Self>,
418 ordinal: u64,
419 buffer: ___T::RecvBuffer,
420 ) {
421 match ordinal {
422 ordinal => {
423 sender.close();
424 }
425 }
426 }
427
428 fn on_two_way(
429 handler: &mut ___H,
430 sender: &::fidl_next::ServerSender<___T, Self>,
431 ordinal: u64,
432 buffer: ___T::RecvBuffer,
433 responder: ::fidl_next::protocol::Responder,
434 ) {
435 match ordinal {
436 6540867515453498750 => {
437 let responder = ::fidl_next::Responder::from_untyped(responder);
438
439 handler.close(sender, responder);
440 }
441
442 ordinal => {
443 sender.close();
444 }
445 }
446 }
447}
448
449#[derive(Clone, Debug)]
450pub struct QueryableQueryResponse {
451 pub protocol: Vec<u8>,
452}
453
454impl ::fidl_next::Encodable for QueryableQueryResponse {
455 type Encoded = WireQueryableQueryResponse<'static>;
456}
457
458unsafe impl<___E> ::fidl_next::Encode<___E> for QueryableQueryResponse
459where
460 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
461
462 ___E: ::fidl_next::Encoder,
463{
464 #[inline]
465 fn encode(
466 self,
467 encoder: &mut ___E,
468 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
469 ) -> Result<(), ::fidl_next::EncodeError> {
470 ::fidl_next::munge! {
471 let Self::Encoded {
472 protocol,
473
474 } = out;
475 }
476
477 ::fidl_next::Encode::encode(self.protocol, encoder, protocol)?;
478
479 Ok(())
480 }
481}
482
483unsafe impl<___E> ::fidl_next::EncodeRef<___E> for QueryableQueryResponse
484where
485 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
486
487 ___E: ::fidl_next::Encoder,
488{
489 #[inline]
490 fn encode_ref(
491 &self,
492 encoder: &mut ___E,
493 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
494 ) -> Result<(), ::fidl_next::EncodeError> {
495 ::fidl_next::munge! {
496 let Self::Encoded {
497 protocol,
498
499 } = out;
500 }
501
502 ::fidl_next::EncodeRef::encode_ref(&self.protocol, encoder, protocol)?;
503
504 Ok(())
505 }
506}
507
508impl ::fidl_next::EncodableOption for QueryableQueryResponse {
509 type EncodedOption = ::fidl_next::WireBox<'static, WireQueryableQueryResponse<'static>>;
510}
511
512unsafe impl<___E> ::fidl_next::EncodeOption<___E> for QueryableQueryResponse
513where
514 ___E: ::fidl_next::Encoder + ?Sized,
515 QueryableQueryResponse: ::fidl_next::Encode<___E>,
516{
517 #[inline]
518 fn encode_option(
519 this: Option<Self>,
520 encoder: &mut ___E,
521 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
522 ) -> Result<(), ::fidl_next::EncodeError> {
523 if let Some(inner) = this {
524 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
525 ::fidl_next::WireBox::encode_present(out);
526 } else {
527 ::fidl_next::WireBox::encode_absent(out);
528 }
529
530 Ok(())
531 }
532}
533
534unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for QueryableQueryResponse
535where
536 ___E: ::fidl_next::Encoder + ?Sized,
537 QueryableQueryResponse: ::fidl_next::EncodeRef<___E>,
538{
539 #[inline]
540 fn encode_option_ref(
541 this: Option<&Self>,
542 encoder: &mut ___E,
543 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
544 ) -> Result<(), ::fidl_next::EncodeError> {
545 if let Some(inner) = this {
546 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
547 ::fidl_next::WireBox::encode_present(out);
548 } else {
549 ::fidl_next::WireBox::encode_absent(out);
550 }
551
552 Ok(())
553 }
554}
555
556impl<'de> ::fidl_next::FromWire<WireQueryableQueryResponse<'de>> for QueryableQueryResponse {
557 #[inline]
558 fn from_wire(wire: WireQueryableQueryResponse<'de>) -> Self {
559 Self { protocol: ::fidl_next::FromWire::from_wire(wire.protocol) }
560 }
561}
562
563impl<'de> ::fidl_next::FromWireRef<WireQueryableQueryResponse<'de>> for QueryableQueryResponse {
564 #[inline]
565 fn from_wire_ref(wire: &WireQueryableQueryResponse<'de>) -> Self {
566 Self { protocol: ::fidl_next::FromWireRef::from_wire_ref(&wire.protocol) }
567 }
568}
569
570#[derive(Debug)]
572#[repr(C)]
573pub struct WireQueryableQueryResponse<'de> {
574 pub protocol: ::fidl_next::WireVector<'de, u8>,
575}
576
577unsafe impl ::fidl_next::Wire for WireQueryableQueryResponse<'static> {
578 type Decoded<'de> = WireQueryableQueryResponse<'de>;
579
580 #[inline]
581 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
582}
583
584unsafe impl<___D> ::fidl_next::Decode<___D> for WireQueryableQueryResponse<'static>
585where
586 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
587
588 ___D: ::fidl_next::Decoder,
589{
590 fn decode(
591 slot: ::fidl_next::Slot<'_, Self>,
592 decoder: &mut ___D,
593 ) -> Result<(), ::fidl_next::DecodeError> {
594 ::fidl_next::munge! {
595 let Self {
596 mut protocol,
597
598 } = slot;
599 }
600
601 ::fidl_next::Decode::decode(protocol.as_mut(), decoder)?;
602
603 Ok(())
604 }
605}
606
607#[doc = " Provides a means of identifying a type-erased protocol.\n"]
609#[derive(Debug)]
610pub struct Queryable;
611
612pub mod queryable {
613 pub mod prelude {
614 pub use crate::{
615 queryable, Queryable, QueryableClientHandler, QueryableClientSender,
616 QueryableServerHandler, QueryableServerSender,
617 };
618
619 pub use crate::QueryableQueryResponse;
620 }
621
622 pub struct Query;
623
624 impl ::fidl_next::Method for Query {
625 const ORDINAL: u64 = 2763219980499352582;
626
627 type Protocol = crate::Queryable;
628
629 type Request = ();
630
631 type Response = crate::WireQueryableQueryResponse<'static>;
632 }
633}
634
635pub trait QueryableClientSender {
637 type Transport: ::fidl_next::Transport;
638
639 fn query(
640 &self,
641 ) -> Result<
642 ::fidl_next::ResponseFuture<'_, Self::Transport, queryable::Query>,
643 ::fidl_next::EncodeError,
644 >;
645}
646
647impl<___T> QueryableClientSender for ::fidl_next::ClientSender<___T, Queryable>
648where
649 ___T: ::fidl_next::Transport,
650{
651 type Transport = ___T;
652
653 fn query(
654 &self,
655 ) -> Result<
656 ::fidl_next::ResponseFuture<'_, Self::Transport, queryable::Query>,
657 ::fidl_next::EncodeError,
658 > {
659 self.as_untyped()
660 .send_two_way(2763219980499352582, ())
661 .map(::fidl_next::ResponseFuture::from_untyped)
662 }
663}
664
665pub trait QueryableClientHandler<___T: ::fidl_next::Transport> {}
669
670impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for Queryable
671where
672 ___T: ::fidl_next::Transport,
673 ___H: QueryableClientHandler<___T>,
674
675 <queryable::Query as ::fidl_next::Method>::Response:
676 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
677{
678 fn on_event(
679 handler: &mut ___H,
680 sender: &::fidl_next::ClientSender<___T, Self>,
681 ordinal: u64,
682 buffer: ___T::RecvBuffer,
683 ) {
684 match ordinal {
685 ordinal => {
686 sender.close();
687 }
688 }
689 }
690}
691
692pub trait QueryableServerSender {
694 type Transport: ::fidl_next::Transport;
695}
696
697impl<___T> QueryableServerSender for ::fidl_next::ServerSender<___T, Queryable>
698where
699 ___T: ::fidl_next::Transport,
700{
701 type Transport = ___T;
702}
703
704pub trait QueryableServerHandler<___T: ::fidl_next::Transport> {
708 fn query(
709 &mut self,
710 sender: &::fidl_next::ServerSender<___T, Queryable>,
711
712 responder: ::fidl_next::Responder<queryable::Query>,
713 );
714}
715
716impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for Queryable
717where
718 ___T: ::fidl_next::Transport,
719 ___H: QueryableServerHandler<___T>,
720{
721 fn on_one_way(
722 handler: &mut ___H,
723 sender: &::fidl_next::ServerSender<___T, Self>,
724 ordinal: u64,
725 buffer: ___T::RecvBuffer,
726 ) {
727 match ordinal {
728 ordinal => {
729 sender.close();
730 }
731 }
732 }
733
734 fn on_two_way(
735 handler: &mut ___H,
736 sender: &::fidl_next::ServerSender<___T, Self>,
737 ordinal: u64,
738 buffer: ___T::RecvBuffer,
739 responder: ::fidl_next::protocol::Responder,
740 ) {
741 match ordinal {
742 2763219980499352582 => {
743 let responder = ::fidl_next::Responder::from_untyped(responder);
744
745 handler.query(sender, responder);
746 }
747
748 ordinal => {
749 sender.close();
750 }
751 }
752 }
753}
754
755pub mod compat {
757
758 #[cfg(target_os = "fuchsia")]
759 pub type CloneableProxy =
762 ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::Cloneable>;
763
764 impl ::core::convert::From<crate::Cloneable> for ::fidl_fuchsia_unknown::CloneableMarker {
765 #[inline]
766 fn from(_: crate::Cloneable) -> Self {
767 Self
768 }
769 }
770
771 #[cfg(target_os = "fuchsia")]
772 pub type CloseableProxy =
775 ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::Closeable>;
776
777 impl ::core::convert::From<crate::Closeable> for ::fidl_fuchsia_unknown::CloseableMarker {
778 #[inline]
779 fn from(_: crate::Closeable) -> Self {
780 Self
781 }
782 }
783
784 #[cfg(target_os = "fuchsia")]
785 pub type QueryableProxy =
788 ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::Queryable>;
789
790 impl ::core::convert::From<crate::Queryable> for ::fidl_fuchsia_unknown::QueryableMarker {
791 #[inline]
792 fn from(_: crate::Queryable) -> Self {
793 Self
794 }
795 }
796}