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