fidl_next_fuchsia_unknown/
fidl_next_fuchsia_unknown.rs

1// DO NOT EDIT: This file is machine-generated by fidlgen
2#![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/// The wire type corresponding to [`CloneableCloneRequest`].
99#[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/// The type corresponding to the Cloneable protocol.
136#[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
163/// A helper trait for the `Cloneable` client sender.
164pub 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
198/// A client handler for the Cloneable protocol.
199///
200/// See [`Cloneable`] for more details.
201pub 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
222/// A helper trait for the `Cloneable` server sender.
223pub 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
234/// A server handler for the Cloneable protocol.
235///
236/// See [`Cloneable`] for more details.
237pub 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
291/// The wire type corresponding to [`CloseableCloseResponse`].
292pub type WireCloseableCloseResponse = ();
293
294/// The type corresponding to the Closeable protocol.
295#[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
326/// A helper trait for the `Closeable` client sender.
327pub 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
358/// A client handler for the Closeable protocol.
359///
360/// See [`Closeable`] for more details.
361pub 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
385/// A helper trait for the `Closeable` server sender.
386pub 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
397/// A server handler for the Closeable protocol.
398///
399/// See [`Closeable`] for more details.
400pub 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/// The wire type corresponding to [`QueryableQueryResponse`].
571#[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/// The type corresponding to the Queryable protocol.
608#[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
635/// A helper trait for the `Queryable` client sender.
636pub 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
665/// A client handler for the Queryable protocol.
666///
667/// See [`Queryable`] for more details.
668pub 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
692/// A helper trait for the `Queryable` server sender.
693pub 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
704/// A server handler for the Queryable protocol.
705///
706/// See [`Queryable`] for more details.
707pub 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
755/// Compatibility shims which mimic some API surfaces of the current Rust bindings.
756pub mod compat {
757
758    #[cfg(target_os = "fuchsia")]
759    /// An alias for a client sender over `zx::Channel` for the `Cloneable`
760    /// protocol.
761    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    /// An alias for a client sender over `zx::Channel` for the `Closeable`
773    /// protocol.
774    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    /// An alias for a client sender over `zx::Channel` for the `Queryable`
786    /// protocol.
787    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}