fidl_fuchsia_posix_socket_raw/
fidl_fuchsia_posix_socket_raw.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::client::QueryResponseFut;
8use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
9use fidl::endpoints::{ControlHandle as _, Responder as _};
10pub use fidl_fuchsia_posix_socket_raw__common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
15pub struct ProviderSocketWithOptionsResponse {
16    pub s: fidl::endpoints::ClientEnd<SocketMarker>,
17}
18
19impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
20    for ProviderSocketWithOptionsResponse
21{
22}
23
24#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
25pub struct ProviderSocketResponse {
26    pub s: fidl::endpoints::ClientEnd<SocketMarker>,
27}
28
29impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for ProviderSocketResponse {}
30
31#[derive(Debug, Default, PartialEq)]
32pub struct SocketDescribeResponse {
33    /// Signals additional information about the state of the socket such as
34    /// readiness or shutdown-ness.
35    pub event: Option<fidl::EventPair>,
36    #[doc(hidden)]
37    pub __source_breaking: fidl::marker::SourceBreaking,
38}
39
40impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for SocketDescribeResponse {}
41
42#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
43pub struct ProviderMarker;
44
45impl fidl::endpoints::ProtocolMarker for ProviderMarker {
46    type Proxy = ProviderProxy;
47    type RequestStream = ProviderRequestStream;
48    #[cfg(target_os = "fuchsia")]
49    type SynchronousProxy = ProviderSynchronousProxy;
50
51    const DEBUG_NAME: &'static str = "fuchsia.posix.socket.raw.Provider";
52}
53impl fidl::endpoints::DiscoverableProtocolMarker for ProviderMarker {}
54pub type ProviderSocketResult =
55    Result<fidl::endpoints::ClientEnd<SocketMarker>, fidl_fuchsia_posix::Errno>;
56pub type ProviderSocketWithOptionsResult =
57    Result<fidl::endpoints::ClientEnd<SocketMarker>, fidl_fuchsia_posix::Errno>;
58
59pub trait ProviderProxyInterface: Send + Sync {
60    type SocketResponseFut: std::future::Future<Output = Result<ProviderSocketResult, fidl::Error>>
61        + Send;
62    fn r#socket(
63        &self,
64        domain: fidl_fuchsia_posix_socket::Domain,
65        proto: &ProtocolAssociation,
66    ) -> Self::SocketResponseFut;
67    type SocketWithOptionsResponseFut: std::future::Future<Output = Result<ProviderSocketWithOptionsResult, fidl::Error>>
68        + Send;
69    fn r#socket_with_options(
70        &self,
71        domain: fidl_fuchsia_posix_socket::Domain,
72        proto: &ProtocolAssociation,
73        opts: &fidl_fuchsia_posix_socket::SocketCreationOptions,
74    ) -> Self::SocketWithOptionsResponseFut;
75}
76#[derive(Debug)]
77#[cfg(target_os = "fuchsia")]
78pub struct ProviderSynchronousProxy {
79    client: fidl::client::sync::Client,
80}
81
82#[cfg(target_os = "fuchsia")]
83impl fidl::endpoints::SynchronousProxy for ProviderSynchronousProxy {
84    type Proxy = ProviderProxy;
85    type Protocol = ProviderMarker;
86
87    fn from_channel(inner: fidl::Channel) -> Self {
88        Self::new(inner)
89    }
90
91    fn into_channel(self) -> fidl::Channel {
92        self.client.into_channel()
93    }
94
95    fn as_channel(&self) -> &fidl::Channel {
96        self.client.as_channel()
97    }
98}
99
100#[cfg(target_os = "fuchsia")]
101impl ProviderSynchronousProxy {
102    pub fn new(channel: fidl::Channel) -> Self {
103        let protocol_name = <ProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
104        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
105    }
106
107    pub fn into_channel(self) -> fidl::Channel {
108        self.client.into_channel()
109    }
110
111    /// Waits until an event arrives and returns it. It is safe for other
112    /// threads to make concurrent requests while waiting for an event.
113    pub fn wait_for_event(
114        &self,
115        deadline: zx::MonotonicInstant,
116    ) -> Result<ProviderEvent, fidl::Error> {
117        ProviderEvent::decode(self.client.wait_for_event(deadline)?)
118    }
119
120    /// Requests a raw socket.
121    pub fn r#socket(
122        &self,
123        mut domain: fidl_fuchsia_posix_socket::Domain,
124        mut proto: &ProtocolAssociation,
125        ___deadline: zx::MonotonicInstant,
126    ) -> Result<ProviderSocketResult, fidl::Error> {
127        let _response =
128            self.client.send_query::<ProviderSocketRequest, fidl::encoding::ResultType<
129                ProviderSocketResponse,
130                fidl_fuchsia_posix::Errno,
131            >>(
132                (domain, proto),
133                0xdfa6a591ab48fd1,
134                fidl::encoding::DynamicFlags::empty(),
135                ___deadline,
136            )?;
137        Ok(_response.map(|x| x.s))
138    }
139
140    /// Requests a raw socket with creation options.
141    pub fn r#socket_with_options(
142        &self,
143        mut domain: fidl_fuchsia_posix_socket::Domain,
144        mut proto: &ProtocolAssociation,
145        mut opts: &fidl_fuchsia_posix_socket::SocketCreationOptions,
146        ___deadline: zx::MonotonicInstant,
147    ) -> Result<ProviderSocketWithOptionsResult, fidl::Error> {
148        let _response =
149            self.client.send_query::<ProviderSocketWithOptionsRequest, fidl::encoding::ResultType<
150                ProviderSocketWithOptionsResponse,
151                fidl_fuchsia_posix::Errno,
152            >>(
153                (domain, proto, opts),
154                0x34cd6e7e82c46f85,
155                fidl::encoding::DynamicFlags::empty(),
156                ___deadline,
157            )?;
158        Ok(_response.map(|x| x.s))
159    }
160}
161
162#[cfg(target_os = "fuchsia")]
163impl From<ProviderSynchronousProxy> for zx::Handle {
164    fn from(value: ProviderSynchronousProxy) -> Self {
165        value.into_channel().into()
166    }
167}
168
169#[cfg(target_os = "fuchsia")]
170impl From<fidl::Channel> for ProviderSynchronousProxy {
171    fn from(value: fidl::Channel) -> Self {
172        Self::new(value)
173    }
174}
175
176#[cfg(target_os = "fuchsia")]
177impl fidl::endpoints::FromClient for ProviderSynchronousProxy {
178    type Protocol = ProviderMarker;
179
180    fn from_client(value: fidl::endpoints::ClientEnd<ProviderMarker>) -> Self {
181        Self::new(value.into_channel())
182    }
183}
184
185#[derive(Debug, Clone)]
186pub struct ProviderProxy {
187    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
188}
189
190impl fidl::endpoints::Proxy for ProviderProxy {
191    type Protocol = ProviderMarker;
192
193    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
194        Self::new(inner)
195    }
196
197    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
198        self.client.into_channel().map_err(|client| Self { client })
199    }
200
201    fn as_channel(&self) -> &::fidl::AsyncChannel {
202        self.client.as_channel()
203    }
204}
205
206impl ProviderProxy {
207    /// Create a new Proxy for fuchsia.posix.socket.raw/Provider.
208    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
209        let protocol_name = <ProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
210        Self { client: fidl::client::Client::new(channel, protocol_name) }
211    }
212
213    /// Get a Stream of events from the remote end of the protocol.
214    ///
215    /// # Panics
216    ///
217    /// Panics if the event stream was already taken.
218    pub fn take_event_stream(&self) -> ProviderEventStream {
219        ProviderEventStream { event_receiver: self.client.take_event_receiver() }
220    }
221
222    /// Requests a raw socket.
223    pub fn r#socket(
224        &self,
225        mut domain: fidl_fuchsia_posix_socket::Domain,
226        mut proto: &ProtocolAssociation,
227    ) -> fidl::client::QueryResponseFut<
228        ProviderSocketResult,
229        fidl::encoding::DefaultFuchsiaResourceDialect,
230    > {
231        ProviderProxyInterface::r#socket(self, domain, proto)
232    }
233
234    /// Requests a raw socket with creation options.
235    pub fn r#socket_with_options(
236        &self,
237        mut domain: fidl_fuchsia_posix_socket::Domain,
238        mut proto: &ProtocolAssociation,
239        mut opts: &fidl_fuchsia_posix_socket::SocketCreationOptions,
240    ) -> fidl::client::QueryResponseFut<
241        ProviderSocketWithOptionsResult,
242        fidl::encoding::DefaultFuchsiaResourceDialect,
243    > {
244        ProviderProxyInterface::r#socket_with_options(self, domain, proto, opts)
245    }
246}
247
248impl ProviderProxyInterface for ProviderProxy {
249    type SocketResponseFut = fidl::client::QueryResponseFut<
250        ProviderSocketResult,
251        fidl::encoding::DefaultFuchsiaResourceDialect,
252    >;
253    fn r#socket(
254        &self,
255        mut domain: fidl_fuchsia_posix_socket::Domain,
256        mut proto: &ProtocolAssociation,
257    ) -> Self::SocketResponseFut {
258        fn _decode(
259            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
260        ) -> Result<ProviderSocketResult, fidl::Error> {
261            let _response = fidl::client::decode_transaction_body::<
262                fidl::encoding::ResultType<ProviderSocketResponse, fidl_fuchsia_posix::Errno>,
263                fidl::encoding::DefaultFuchsiaResourceDialect,
264                0xdfa6a591ab48fd1,
265            >(_buf?)?;
266            Ok(_response.map(|x| x.s))
267        }
268        self.client.send_query_and_decode::<ProviderSocketRequest, ProviderSocketResult>(
269            (domain, proto),
270            0xdfa6a591ab48fd1,
271            fidl::encoding::DynamicFlags::empty(),
272            _decode,
273        )
274    }
275
276    type SocketWithOptionsResponseFut = fidl::client::QueryResponseFut<
277        ProviderSocketWithOptionsResult,
278        fidl::encoding::DefaultFuchsiaResourceDialect,
279    >;
280    fn r#socket_with_options(
281        &self,
282        mut domain: fidl_fuchsia_posix_socket::Domain,
283        mut proto: &ProtocolAssociation,
284        mut opts: &fidl_fuchsia_posix_socket::SocketCreationOptions,
285    ) -> Self::SocketWithOptionsResponseFut {
286        fn _decode(
287            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
288        ) -> Result<ProviderSocketWithOptionsResult, fidl::Error> {
289            let _response = fidl::client::decode_transaction_body::<
290                fidl::encoding::ResultType<
291                    ProviderSocketWithOptionsResponse,
292                    fidl_fuchsia_posix::Errno,
293                >,
294                fidl::encoding::DefaultFuchsiaResourceDialect,
295                0x34cd6e7e82c46f85,
296            >(_buf?)?;
297            Ok(_response.map(|x| x.s))
298        }
299        self.client.send_query_and_decode::<
300            ProviderSocketWithOptionsRequest,
301            ProviderSocketWithOptionsResult,
302        >(
303            (domain, proto, opts,),
304            0x34cd6e7e82c46f85,
305            fidl::encoding::DynamicFlags::empty(),
306            _decode,
307        )
308    }
309}
310
311pub struct ProviderEventStream {
312    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
313}
314
315impl std::marker::Unpin for ProviderEventStream {}
316
317impl futures::stream::FusedStream for ProviderEventStream {
318    fn is_terminated(&self) -> bool {
319        self.event_receiver.is_terminated()
320    }
321}
322
323impl futures::Stream for ProviderEventStream {
324    type Item = Result<ProviderEvent, fidl::Error>;
325
326    fn poll_next(
327        mut self: std::pin::Pin<&mut Self>,
328        cx: &mut std::task::Context<'_>,
329    ) -> std::task::Poll<Option<Self::Item>> {
330        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
331            &mut self.event_receiver,
332            cx
333        )?) {
334            Some(buf) => std::task::Poll::Ready(Some(ProviderEvent::decode(buf))),
335            None => std::task::Poll::Ready(None),
336        }
337    }
338}
339
340#[derive(Debug)]
341pub enum ProviderEvent {}
342
343impl ProviderEvent {
344    /// Decodes a message buffer as a [`ProviderEvent`].
345    fn decode(
346        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
347    ) -> Result<ProviderEvent, fidl::Error> {
348        let (bytes, _handles) = buf.split_mut();
349        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
350        debug_assert_eq!(tx_header.tx_id, 0);
351        match tx_header.ordinal {
352            _ => Err(fidl::Error::UnknownOrdinal {
353                ordinal: tx_header.ordinal,
354                protocol_name: <ProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
355            }),
356        }
357    }
358}
359
360/// A Stream of incoming requests for fuchsia.posix.socket.raw/Provider.
361pub struct ProviderRequestStream {
362    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
363    is_terminated: bool,
364}
365
366impl std::marker::Unpin for ProviderRequestStream {}
367
368impl futures::stream::FusedStream for ProviderRequestStream {
369    fn is_terminated(&self) -> bool {
370        self.is_terminated
371    }
372}
373
374impl fidl::endpoints::RequestStream for ProviderRequestStream {
375    type Protocol = ProviderMarker;
376    type ControlHandle = ProviderControlHandle;
377
378    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
379        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
380    }
381
382    fn control_handle(&self) -> Self::ControlHandle {
383        ProviderControlHandle { inner: self.inner.clone() }
384    }
385
386    fn into_inner(
387        self,
388    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
389    {
390        (self.inner, self.is_terminated)
391    }
392
393    fn from_inner(
394        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
395        is_terminated: bool,
396    ) -> Self {
397        Self { inner, is_terminated }
398    }
399}
400
401impl futures::Stream for ProviderRequestStream {
402    type Item = Result<ProviderRequest, fidl::Error>;
403
404    fn poll_next(
405        mut self: std::pin::Pin<&mut Self>,
406        cx: &mut std::task::Context<'_>,
407    ) -> std::task::Poll<Option<Self::Item>> {
408        let this = &mut *self;
409        if this.inner.check_shutdown(cx) {
410            this.is_terminated = true;
411            return std::task::Poll::Ready(None);
412        }
413        if this.is_terminated {
414            panic!("polled ProviderRequestStream after completion");
415        }
416        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
417            |bytes, handles| {
418                match this.inner.channel().read_etc(cx, bytes, handles) {
419                    std::task::Poll::Ready(Ok(())) => {}
420                    std::task::Poll::Pending => return std::task::Poll::Pending,
421                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
422                        this.is_terminated = true;
423                        return std::task::Poll::Ready(None);
424                    }
425                    std::task::Poll::Ready(Err(e)) => {
426                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
427                            e.into(),
428                        ))))
429                    }
430                }
431
432                // A message has been received from the channel
433                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
434
435                std::task::Poll::Ready(Some(match header.ordinal {
436                    0xdfa6a591ab48fd1 => {
437                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
438                        let mut req = fidl::new_empty!(
439                            ProviderSocketRequest,
440                            fidl::encoding::DefaultFuchsiaResourceDialect
441                        );
442                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ProviderSocketRequest>(&header, _body_bytes, handles, &mut req)?;
443                        let control_handle = ProviderControlHandle { inner: this.inner.clone() };
444                        Ok(ProviderRequest::Socket {
445                            domain: req.domain,
446                            proto: req.proto,
447
448                            responder: ProviderSocketResponder {
449                                control_handle: std::mem::ManuallyDrop::new(control_handle),
450                                tx_id: header.tx_id,
451                            },
452                        })
453                    }
454                    0x34cd6e7e82c46f85 => {
455                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
456                        let mut req = fidl::new_empty!(
457                            ProviderSocketWithOptionsRequest,
458                            fidl::encoding::DefaultFuchsiaResourceDialect
459                        );
460                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ProviderSocketWithOptionsRequest>(&header, _body_bytes, handles, &mut req)?;
461                        let control_handle = ProviderControlHandle { inner: this.inner.clone() };
462                        Ok(ProviderRequest::SocketWithOptions {
463                            domain: req.domain,
464                            proto: req.proto,
465                            opts: req.opts,
466
467                            responder: ProviderSocketWithOptionsResponder {
468                                control_handle: std::mem::ManuallyDrop::new(control_handle),
469                                tx_id: header.tx_id,
470                            },
471                        })
472                    }
473                    _ => Err(fidl::Error::UnknownOrdinal {
474                        ordinal: header.ordinal,
475                        protocol_name:
476                            <ProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
477                    }),
478                }))
479            },
480        )
481    }
482}
483
484/// A raw network socket provider.
485#[derive(Debug)]
486pub enum ProviderRequest {
487    /// Requests a raw socket.
488    Socket {
489        domain: fidl_fuchsia_posix_socket::Domain,
490        proto: ProtocolAssociation,
491        responder: ProviderSocketResponder,
492    },
493    /// Requests a raw socket with creation options.
494    SocketWithOptions {
495        domain: fidl_fuchsia_posix_socket::Domain,
496        proto: ProtocolAssociation,
497        opts: fidl_fuchsia_posix_socket::SocketCreationOptions,
498        responder: ProviderSocketWithOptionsResponder,
499    },
500}
501
502impl ProviderRequest {
503    #[allow(irrefutable_let_patterns)]
504    pub fn into_socket(
505        self,
506    ) -> Option<(fidl_fuchsia_posix_socket::Domain, ProtocolAssociation, ProviderSocketResponder)>
507    {
508        if let ProviderRequest::Socket { domain, proto, responder } = self {
509            Some((domain, proto, responder))
510        } else {
511            None
512        }
513    }
514
515    #[allow(irrefutable_let_patterns)]
516    pub fn into_socket_with_options(
517        self,
518    ) -> Option<(
519        fidl_fuchsia_posix_socket::Domain,
520        ProtocolAssociation,
521        fidl_fuchsia_posix_socket::SocketCreationOptions,
522        ProviderSocketWithOptionsResponder,
523    )> {
524        if let ProviderRequest::SocketWithOptions { domain, proto, opts, responder } = self {
525            Some((domain, proto, opts, responder))
526        } else {
527            None
528        }
529    }
530
531    /// Name of the method defined in FIDL
532    pub fn method_name(&self) -> &'static str {
533        match *self {
534            ProviderRequest::Socket { .. } => "socket",
535            ProviderRequest::SocketWithOptions { .. } => "socket_with_options",
536        }
537    }
538}
539
540#[derive(Debug, Clone)]
541pub struct ProviderControlHandle {
542    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
543}
544
545impl fidl::endpoints::ControlHandle for ProviderControlHandle {
546    fn shutdown(&self) {
547        self.inner.shutdown()
548    }
549    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
550        self.inner.shutdown_with_epitaph(status)
551    }
552
553    fn is_closed(&self) -> bool {
554        self.inner.channel().is_closed()
555    }
556    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
557        self.inner.channel().on_closed()
558    }
559
560    #[cfg(target_os = "fuchsia")]
561    fn signal_peer(
562        &self,
563        clear_mask: zx::Signals,
564        set_mask: zx::Signals,
565    ) -> Result<(), zx_status::Status> {
566        use fidl::Peered;
567        self.inner.channel().signal_peer(clear_mask, set_mask)
568    }
569}
570
571impl ProviderControlHandle {}
572
573#[must_use = "FIDL methods require a response to be sent"]
574#[derive(Debug)]
575pub struct ProviderSocketResponder {
576    control_handle: std::mem::ManuallyDrop<ProviderControlHandle>,
577    tx_id: u32,
578}
579
580/// Set the the channel to be shutdown (see [`ProviderControlHandle::shutdown`])
581/// if the responder is dropped without sending a response, so that the client
582/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
583impl std::ops::Drop for ProviderSocketResponder {
584    fn drop(&mut self) {
585        self.control_handle.shutdown();
586        // Safety: drops once, never accessed again
587        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
588    }
589}
590
591impl fidl::endpoints::Responder for ProviderSocketResponder {
592    type ControlHandle = ProviderControlHandle;
593
594    fn control_handle(&self) -> &ProviderControlHandle {
595        &self.control_handle
596    }
597
598    fn drop_without_shutdown(mut self) {
599        // Safety: drops once, never accessed again due to mem::forget
600        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
601        // Prevent Drop from running (which would shut down the channel)
602        std::mem::forget(self);
603    }
604}
605
606impl ProviderSocketResponder {
607    /// Sends a response to the FIDL transaction.
608    ///
609    /// Sets the channel to shutdown if an error occurs.
610    pub fn send(
611        self,
612        mut result: Result<fidl::endpoints::ClientEnd<SocketMarker>, fidl_fuchsia_posix::Errno>,
613    ) -> Result<(), fidl::Error> {
614        let _result = self.send_raw(result);
615        if _result.is_err() {
616            self.control_handle.shutdown();
617        }
618        self.drop_without_shutdown();
619        _result
620    }
621
622    /// Similar to "send" but does not shutdown the channel if an error occurs.
623    pub fn send_no_shutdown_on_err(
624        self,
625        mut result: Result<fidl::endpoints::ClientEnd<SocketMarker>, fidl_fuchsia_posix::Errno>,
626    ) -> Result<(), fidl::Error> {
627        let _result = self.send_raw(result);
628        self.drop_without_shutdown();
629        _result
630    }
631
632    fn send_raw(
633        &self,
634        mut result: Result<fidl::endpoints::ClientEnd<SocketMarker>, fidl_fuchsia_posix::Errno>,
635    ) -> Result<(), fidl::Error> {
636        self.control_handle.inner.send::<fidl::encoding::ResultType<
637            ProviderSocketResponse,
638            fidl_fuchsia_posix::Errno,
639        >>(
640            result.map(|s| (s,)),
641            self.tx_id,
642            0xdfa6a591ab48fd1,
643            fidl::encoding::DynamicFlags::empty(),
644        )
645    }
646}
647
648#[must_use = "FIDL methods require a response to be sent"]
649#[derive(Debug)]
650pub struct ProviderSocketWithOptionsResponder {
651    control_handle: std::mem::ManuallyDrop<ProviderControlHandle>,
652    tx_id: u32,
653}
654
655/// Set the the channel to be shutdown (see [`ProviderControlHandle::shutdown`])
656/// if the responder is dropped without sending a response, so that the client
657/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
658impl std::ops::Drop for ProviderSocketWithOptionsResponder {
659    fn drop(&mut self) {
660        self.control_handle.shutdown();
661        // Safety: drops once, never accessed again
662        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
663    }
664}
665
666impl fidl::endpoints::Responder for ProviderSocketWithOptionsResponder {
667    type ControlHandle = ProviderControlHandle;
668
669    fn control_handle(&self) -> &ProviderControlHandle {
670        &self.control_handle
671    }
672
673    fn drop_without_shutdown(mut self) {
674        // Safety: drops once, never accessed again due to mem::forget
675        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
676        // Prevent Drop from running (which would shut down the channel)
677        std::mem::forget(self);
678    }
679}
680
681impl ProviderSocketWithOptionsResponder {
682    /// Sends a response to the FIDL transaction.
683    ///
684    /// Sets the channel to shutdown if an error occurs.
685    pub fn send(
686        self,
687        mut result: Result<fidl::endpoints::ClientEnd<SocketMarker>, fidl_fuchsia_posix::Errno>,
688    ) -> Result<(), fidl::Error> {
689        let _result = self.send_raw(result);
690        if _result.is_err() {
691            self.control_handle.shutdown();
692        }
693        self.drop_without_shutdown();
694        _result
695    }
696
697    /// Similar to "send" but does not shutdown the channel if an error occurs.
698    pub fn send_no_shutdown_on_err(
699        self,
700        mut result: Result<fidl::endpoints::ClientEnd<SocketMarker>, fidl_fuchsia_posix::Errno>,
701    ) -> Result<(), fidl::Error> {
702        let _result = self.send_raw(result);
703        self.drop_without_shutdown();
704        _result
705    }
706
707    fn send_raw(
708        &self,
709        mut result: Result<fidl::endpoints::ClientEnd<SocketMarker>, fidl_fuchsia_posix::Errno>,
710    ) -> Result<(), fidl::Error> {
711        self.control_handle.inner.send::<fidl::encoding::ResultType<
712            ProviderSocketWithOptionsResponse,
713            fidl_fuchsia_posix::Errno,
714        >>(
715            result.map(|s| (s,)),
716            self.tx_id,
717            0x34cd6e7e82c46f85,
718            fidl::encoding::DynamicFlags::empty(),
719        )
720    }
721}
722
723#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
724pub struct SocketMarker;
725
726impl fidl::endpoints::ProtocolMarker for SocketMarker {
727    type Proxy = SocketProxy;
728    type RequestStream = SocketRequestStream;
729    #[cfg(target_os = "fuchsia")]
730    type SynchronousProxy = SocketSynchronousProxy;
731
732    const DEBUG_NAME: &'static str = "fuchsia.posix.socket.raw.Socket";
733}
734impl fidl::endpoints::DiscoverableProtocolMarker for SocketMarker {}
735pub type SocketRecvMsgResult = Result<
736    (
737        Option<Box<fidl_fuchsia_net::SocketAddress>>,
738        Vec<u8>,
739        fidl_fuchsia_posix_socket::NetworkSocketRecvControlData,
740        u32,
741    ),
742    fidl_fuchsia_posix::Errno,
743>;
744pub type SocketSendMsgResult = Result<(), fidl_fuchsia_posix::Errno>;
745pub type SocketGetInfoResult =
746    Result<(fidl_fuchsia_posix_socket::Domain, ProtocolAssociation), fidl_fuchsia_posix::Errno>;
747pub type SocketSetIpHeaderIncludedResult = Result<(), fidl_fuchsia_posix::Errno>;
748pub type SocketGetIpHeaderIncludedResult = Result<bool, fidl_fuchsia_posix::Errno>;
749pub type SocketSetIcmpv6FilterResult = Result<(), fidl_fuchsia_posix::Errno>;
750pub type SocketGetIcmpv6FilterResult = Result<Icmpv6Filter, fidl_fuchsia_posix::Errno>;
751pub type SocketSetIpv6ChecksumResult = Result<(), fidl_fuchsia_posix::Errno>;
752pub type SocketGetIpv6ChecksumResult = Result<Ipv6ChecksumConfiguration, fidl_fuchsia_posix::Errno>;
753
754pub trait SocketProxyInterface: Send + Sync {
755    fn r#clone(
756        &self,
757        request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
758    ) -> Result<(), fidl::Error>;
759    type CloseResponseFut: std::future::Future<
760            Output = Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error>,
761        > + Send;
762    fn r#close(&self) -> Self::CloseResponseFut;
763    type QueryResponseFut: std::future::Future<Output = Result<Vec<u8>, fidl::Error>> + Send;
764    fn r#query(&self) -> Self::QueryResponseFut;
765    type SetReuseAddressResponseFut: std::future::Future<
766            Output = Result<
767                fidl_fuchsia_posix_socket::BaseSocketSetReuseAddressResult,
768                fidl::Error,
769            >,
770        > + Send;
771    fn r#set_reuse_address(&self, value: bool) -> Self::SetReuseAddressResponseFut;
772    type GetReuseAddressResponseFut: std::future::Future<
773            Output = Result<
774                fidl_fuchsia_posix_socket::BaseSocketGetReuseAddressResult,
775                fidl::Error,
776            >,
777        > + Send;
778    fn r#get_reuse_address(&self) -> Self::GetReuseAddressResponseFut;
779    type GetErrorResponseFut: std::future::Future<
780            Output = Result<fidl_fuchsia_posix_socket::BaseSocketGetErrorResult, fidl::Error>,
781        > + Send;
782    fn r#get_error(&self) -> Self::GetErrorResponseFut;
783    type SetBroadcastResponseFut: std::future::Future<
784            Output = Result<fidl_fuchsia_posix_socket::BaseSocketSetBroadcastResult, fidl::Error>,
785        > + Send;
786    fn r#set_broadcast(&self, value: bool) -> Self::SetBroadcastResponseFut;
787    type GetBroadcastResponseFut: std::future::Future<
788            Output = Result<fidl_fuchsia_posix_socket::BaseSocketGetBroadcastResult, fidl::Error>,
789        > + Send;
790    fn r#get_broadcast(&self) -> Self::GetBroadcastResponseFut;
791    type SetSendBufferResponseFut: std::future::Future<
792            Output = Result<fidl_fuchsia_posix_socket::BaseSocketSetSendBufferResult, fidl::Error>,
793        > + Send;
794    fn r#set_send_buffer(&self, value_bytes: u64) -> Self::SetSendBufferResponseFut;
795    type GetSendBufferResponseFut: std::future::Future<
796            Output = Result<fidl_fuchsia_posix_socket::BaseSocketGetSendBufferResult, fidl::Error>,
797        > + Send;
798    fn r#get_send_buffer(&self) -> Self::GetSendBufferResponseFut;
799    type SetReceiveBufferResponseFut: std::future::Future<
800            Output = Result<
801                fidl_fuchsia_posix_socket::BaseSocketSetReceiveBufferResult,
802                fidl::Error,
803            >,
804        > + Send;
805    fn r#set_receive_buffer(&self, value_bytes: u64) -> Self::SetReceiveBufferResponseFut;
806    type GetReceiveBufferResponseFut: std::future::Future<
807            Output = Result<
808                fidl_fuchsia_posix_socket::BaseSocketGetReceiveBufferResult,
809                fidl::Error,
810            >,
811        > + Send;
812    fn r#get_receive_buffer(&self) -> Self::GetReceiveBufferResponseFut;
813    type SetKeepAliveResponseFut: std::future::Future<
814            Output = Result<fidl_fuchsia_posix_socket::BaseSocketSetKeepAliveResult, fidl::Error>,
815        > + Send;
816    fn r#set_keep_alive(&self, value: bool) -> Self::SetKeepAliveResponseFut;
817    type GetKeepAliveResponseFut: std::future::Future<
818            Output = Result<fidl_fuchsia_posix_socket::BaseSocketGetKeepAliveResult, fidl::Error>,
819        > + Send;
820    fn r#get_keep_alive(&self) -> Self::GetKeepAliveResponseFut;
821    type SetOutOfBandInlineResponseFut: std::future::Future<
822            Output = Result<
823                fidl_fuchsia_posix_socket::BaseSocketSetOutOfBandInlineResult,
824                fidl::Error,
825            >,
826        > + Send;
827    fn r#set_out_of_band_inline(&self, value: bool) -> Self::SetOutOfBandInlineResponseFut;
828    type GetOutOfBandInlineResponseFut: std::future::Future<
829            Output = Result<
830                fidl_fuchsia_posix_socket::BaseSocketGetOutOfBandInlineResult,
831                fidl::Error,
832            >,
833        > + Send;
834    fn r#get_out_of_band_inline(&self) -> Self::GetOutOfBandInlineResponseFut;
835    type SetNoCheckResponseFut: std::future::Future<
836            Output = Result<fidl_fuchsia_posix_socket::BaseSocketSetNoCheckResult, fidl::Error>,
837        > + Send;
838    fn r#set_no_check(&self, value: bool) -> Self::SetNoCheckResponseFut;
839    type GetNoCheckResponseFut: std::future::Future<
840            Output = Result<fidl_fuchsia_posix_socket::BaseSocketGetNoCheckResult, fidl::Error>,
841        > + Send;
842    fn r#get_no_check(&self) -> Self::GetNoCheckResponseFut;
843    type SetLingerResponseFut: std::future::Future<
844            Output = Result<fidl_fuchsia_posix_socket::BaseSocketSetLingerResult, fidl::Error>,
845        > + Send;
846    fn r#set_linger(&self, linger: bool, length_secs: u32) -> Self::SetLingerResponseFut;
847    type GetLingerResponseFut: std::future::Future<
848            Output = Result<fidl_fuchsia_posix_socket::BaseSocketGetLingerResult, fidl::Error>,
849        > + Send;
850    fn r#get_linger(&self) -> Self::GetLingerResponseFut;
851    type SetReusePortResponseFut: std::future::Future<
852            Output = Result<fidl_fuchsia_posix_socket::BaseSocketSetReusePortResult, fidl::Error>,
853        > + Send;
854    fn r#set_reuse_port(&self, value: bool) -> Self::SetReusePortResponseFut;
855    type GetReusePortResponseFut: std::future::Future<
856            Output = Result<fidl_fuchsia_posix_socket::BaseSocketGetReusePortResult, fidl::Error>,
857        > + Send;
858    fn r#get_reuse_port(&self) -> Self::GetReusePortResponseFut;
859    type GetAcceptConnResponseFut: std::future::Future<
860            Output = Result<fidl_fuchsia_posix_socket::BaseSocketGetAcceptConnResult, fidl::Error>,
861        > + Send;
862    fn r#get_accept_conn(&self) -> Self::GetAcceptConnResponseFut;
863    type SetBindToDeviceResponseFut: std::future::Future<
864            Output = Result<
865                fidl_fuchsia_posix_socket::BaseSocketSetBindToDeviceResult,
866                fidl::Error,
867            >,
868        > + Send;
869    fn r#set_bind_to_device(&self, value: &str) -> Self::SetBindToDeviceResponseFut;
870    type GetBindToDeviceResponseFut: std::future::Future<
871            Output = Result<
872                fidl_fuchsia_posix_socket::BaseSocketGetBindToDeviceResult,
873                fidl::Error,
874            >,
875        > + Send;
876    fn r#get_bind_to_device(&self) -> Self::GetBindToDeviceResponseFut;
877    type SetBindToInterfaceIndexResponseFut: std::future::Future<
878            Output = Result<
879                fidl_fuchsia_posix_socket::BaseSocketSetBindToInterfaceIndexResult,
880                fidl::Error,
881            >,
882        > + Send;
883    fn r#set_bind_to_interface_index(&self, value: u64)
884        -> Self::SetBindToInterfaceIndexResponseFut;
885    type GetBindToInterfaceIndexResponseFut: std::future::Future<
886            Output = Result<
887                fidl_fuchsia_posix_socket::BaseSocketGetBindToInterfaceIndexResult,
888                fidl::Error,
889            >,
890        > + Send;
891    fn r#get_bind_to_interface_index(&self) -> Self::GetBindToInterfaceIndexResponseFut;
892    type SetTimestampResponseFut: std::future::Future<
893            Output = Result<fidl_fuchsia_posix_socket::BaseSocketSetTimestampResult, fidl::Error>,
894        > + Send;
895    fn r#set_timestamp(
896        &self,
897        value: fidl_fuchsia_posix_socket::TimestampOption,
898    ) -> Self::SetTimestampResponseFut;
899    type GetTimestampResponseFut: std::future::Future<
900            Output = Result<fidl_fuchsia_posix_socket::BaseSocketGetTimestampResult, fidl::Error>,
901        > + Send;
902    fn r#get_timestamp(&self) -> Self::GetTimestampResponseFut;
903    type SetMarkResponseFut: std::future::Future<
904            Output = Result<fidl_fuchsia_posix_socket::BaseSocketSetMarkResult, fidl::Error>,
905        > + Send;
906    fn r#set_mark(
907        &self,
908        domain: fidl_fuchsia_net::MarkDomain,
909        mark: &fidl_fuchsia_posix_socket::OptionalUint32,
910    ) -> Self::SetMarkResponseFut;
911    type GetMarkResponseFut: std::future::Future<
912            Output = Result<fidl_fuchsia_posix_socket::BaseSocketGetMarkResult, fidl::Error>,
913        > + Send;
914    fn r#get_mark(&self, domain: fidl_fuchsia_net::MarkDomain) -> Self::GetMarkResponseFut;
915    type GetCookieResponseFut: std::future::Future<
916            Output = Result<fidl_fuchsia_posix_socket::BaseSocketGetCookieResult, fidl::Error>,
917        > + Send;
918    fn r#get_cookie(&self) -> Self::GetCookieResponseFut;
919    type BindResponseFut: std::future::Future<
920            Output = Result<fidl_fuchsia_posix_socket::BaseNetworkSocketBindResult, fidl::Error>,
921        > + Send;
922    fn r#bind(&self, addr: &fidl_fuchsia_net::SocketAddress) -> Self::BindResponseFut;
923    type ConnectResponseFut: std::future::Future<
924            Output = Result<fidl_fuchsia_posix_socket::BaseNetworkSocketConnectResult, fidl::Error>,
925        > + Send;
926    fn r#connect(&self, addr: &fidl_fuchsia_net::SocketAddress) -> Self::ConnectResponseFut;
927    type DisconnectResponseFut: std::future::Future<
928            Output = Result<
929                fidl_fuchsia_posix_socket::BaseNetworkSocketDisconnectResult,
930                fidl::Error,
931            >,
932        > + Send;
933    fn r#disconnect(&self) -> Self::DisconnectResponseFut;
934    type GetSockNameResponseFut: std::future::Future<
935            Output = Result<
936                fidl_fuchsia_posix_socket::BaseNetworkSocketGetSockNameResult,
937                fidl::Error,
938            >,
939        > + Send;
940    fn r#get_sock_name(&self) -> Self::GetSockNameResponseFut;
941    type GetPeerNameResponseFut: std::future::Future<
942            Output = Result<
943                fidl_fuchsia_posix_socket::BaseNetworkSocketGetPeerNameResult,
944                fidl::Error,
945            >,
946        > + Send;
947    fn r#get_peer_name(&self) -> Self::GetPeerNameResponseFut;
948    type ShutdownResponseFut: std::future::Future<
949            Output = Result<
950                fidl_fuchsia_posix_socket::BaseNetworkSocketShutdownResult,
951                fidl::Error,
952            >,
953        > + Send;
954    fn r#shutdown(
955        &self,
956        mode: fidl_fuchsia_posix_socket::ShutdownMode,
957    ) -> Self::ShutdownResponseFut;
958    type SetIpTypeOfServiceResponseFut: std::future::Future<
959            Output = Result<
960                fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTypeOfServiceResult,
961                fidl::Error,
962            >,
963        > + Send;
964    fn r#set_ip_type_of_service(&self, value: u8) -> Self::SetIpTypeOfServiceResponseFut;
965    type GetIpTypeOfServiceResponseFut: std::future::Future<
966            Output = Result<
967                fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTypeOfServiceResult,
968                fidl::Error,
969            >,
970        > + Send;
971    fn r#get_ip_type_of_service(&self) -> Self::GetIpTypeOfServiceResponseFut;
972    type SetIpTtlResponseFut: std::future::Future<
973            Output = Result<
974                fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTtlResult,
975                fidl::Error,
976            >,
977        > + Send;
978    fn r#set_ip_ttl(
979        &self,
980        value: &fidl_fuchsia_posix_socket::OptionalUint8,
981    ) -> Self::SetIpTtlResponseFut;
982    type GetIpTtlResponseFut: std::future::Future<
983            Output = Result<
984                fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTtlResult,
985                fidl::Error,
986            >,
987        > + Send;
988    fn r#get_ip_ttl(&self) -> Self::GetIpTtlResponseFut;
989    type SetIpPacketInfoResponseFut: std::future::Future<
990            Output = Result<
991                fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpPacketInfoResult,
992                fidl::Error,
993            >,
994        > + Send;
995    fn r#set_ip_packet_info(&self, value: bool) -> Self::SetIpPacketInfoResponseFut;
996    type GetIpPacketInfoResponseFut: std::future::Future<
997            Output = Result<
998                fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpPacketInfoResult,
999                fidl::Error,
1000            >,
1001        > + Send;
1002    fn r#get_ip_packet_info(&self) -> Self::GetIpPacketInfoResponseFut;
1003    type SetIpReceiveTypeOfServiceResponseFut: std::future::Future<
1004            Output = Result<
1005                fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
1006                fidl::Error,
1007            >,
1008        > + Send;
1009    fn r#set_ip_receive_type_of_service(
1010        &self,
1011        value: bool,
1012    ) -> Self::SetIpReceiveTypeOfServiceResponseFut;
1013    type GetIpReceiveTypeOfServiceResponseFut: std::future::Future<
1014            Output = Result<
1015                fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
1016                fidl::Error,
1017            >,
1018        > + Send;
1019    fn r#get_ip_receive_type_of_service(&self) -> Self::GetIpReceiveTypeOfServiceResponseFut;
1020    type SetIpReceiveTtlResponseFut: std::future::Future<
1021            Output = Result<
1022                fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveTtlResult,
1023                fidl::Error,
1024            >,
1025        > + Send;
1026    fn r#set_ip_receive_ttl(&self, value: bool) -> Self::SetIpReceiveTtlResponseFut;
1027    type GetIpReceiveTtlResponseFut: std::future::Future<
1028            Output = Result<
1029                fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveTtlResult,
1030                fidl::Error,
1031            >,
1032        > + Send;
1033    fn r#get_ip_receive_ttl(&self) -> Self::GetIpReceiveTtlResponseFut;
1034    type SetIpMulticastInterfaceResponseFut: std::future::Future<
1035            Output = Result<
1036                fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastInterfaceResult,
1037                fidl::Error,
1038            >,
1039        > + Send;
1040    fn r#set_ip_multicast_interface(
1041        &self,
1042        iface: u64,
1043        address: &fidl_fuchsia_net::Ipv4Address,
1044    ) -> Self::SetIpMulticastInterfaceResponseFut;
1045    type GetIpMulticastInterfaceResponseFut: std::future::Future<
1046            Output = Result<
1047                fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastInterfaceResult,
1048                fidl::Error,
1049            >,
1050        > + Send;
1051    fn r#get_ip_multicast_interface(&self) -> Self::GetIpMulticastInterfaceResponseFut;
1052    type SetIpMulticastTtlResponseFut: std::future::Future<
1053            Output = Result<
1054                fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastTtlResult,
1055                fidl::Error,
1056            >,
1057        > + Send;
1058    fn r#set_ip_multicast_ttl(
1059        &self,
1060        value: &fidl_fuchsia_posix_socket::OptionalUint8,
1061    ) -> Self::SetIpMulticastTtlResponseFut;
1062    type GetIpMulticastTtlResponseFut: std::future::Future<
1063            Output = Result<
1064                fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastTtlResult,
1065                fidl::Error,
1066            >,
1067        > + Send;
1068    fn r#get_ip_multicast_ttl(&self) -> Self::GetIpMulticastTtlResponseFut;
1069    type SetIpMulticastLoopbackResponseFut: std::future::Future<
1070            Output = Result<
1071                fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastLoopbackResult,
1072                fidl::Error,
1073            >,
1074        > + Send;
1075    fn r#set_ip_multicast_loopback(&self, value: bool) -> Self::SetIpMulticastLoopbackResponseFut;
1076    type GetIpMulticastLoopbackResponseFut: std::future::Future<
1077            Output = Result<
1078                fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastLoopbackResult,
1079                fidl::Error,
1080            >,
1081        > + Send;
1082    fn r#get_ip_multicast_loopback(&self) -> Self::GetIpMulticastLoopbackResponseFut;
1083    type AddIpMembershipResponseFut: std::future::Future<
1084            Output = Result<
1085                fidl_fuchsia_posix_socket::BaseNetworkSocketAddIpMembershipResult,
1086                fidl::Error,
1087            >,
1088        > + Send;
1089    fn r#add_ip_membership(
1090        &self,
1091        membership: &fidl_fuchsia_posix_socket::IpMulticastMembership,
1092    ) -> Self::AddIpMembershipResponseFut;
1093    type DropIpMembershipResponseFut: std::future::Future<
1094            Output = Result<
1095                fidl_fuchsia_posix_socket::BaseNetworkSocketDropIpMembershipResult,
1096                fidl::Error,
1097            >,
1098        > + Send;
1099    fn r#drop_ip_membership(
1100        &self,
1101        membership: &fidl_fuchsia_posix_socket::IpMulticastMembership,
1102    ) -> Self::DropIpMembershipResponseFut;
1103    type SetIpTransparentResponseFut: std::future::Future<
1104            Output = Result<
1105                fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTransparentResult,
1106                fidl::Error,
1107            >,
1108        > + Send;
1109    fn r#set_ip_transparent(&self, value: bool) -> Self::SetIpTransparentResponseFut;
1110    type GetIpTransparentResponseFut: std::future::Future<
1111            Output = Result<
1112                fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTransparentResult,
1113                fidl::Error,
1114            >,
1115        > + Send;
1116    fn r#get_ip_transparent(&self) -> Self::GetIpTransparentResponseFut;
1117    type SetIpReceiveOriginalDestinationAddressResponseFut: std::future::Future<Output = Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, fidl::Error>> + Send;
1118    fn r#set_ip_receive_original_destination_address(
1119        &self,
1120        value: bool,
1121    ) -> Self::SetIpReceiveOriginalDestinationAddressResponseFut;
1122    type GetIpReceiveOriginalDestinationAddressResponseFut: std::future::Future<Output = Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, fidl::Error>> + Send;
1123    fn r#get_ip_receive_original_destination_address(
1124        &self,
1125    ) -> Self::GetIpReceiveOriginalDestinationAddressResponseFut;
1126    type AddIpv6MembershipResponseFut: std::future::Future<
1127            Output = Result<
1128                fidl_fuchsia_posix_socket::BaseNetworkSocketAddIpv6MembershipResult,
1129                fidl::Error,
1130            >,
1131        > + Send;
1132    fn r#add_ipv6_membership(
1133        &self,
1134        membership: &fidl_fuchsia_posix_socket::Ipv6MulticastMembership,
1135    ) -> Self::AddIpv6MembershipResponseFut;
1136    type DropIpv6MembershipResponseFut: std::future::Future<
1137            Output = Result<
1138                fidl_fuchsia_posix_socket::BaseNetworkSocketDropIpv6MembershipResult,
1139                fidl::Error,
1140            >,
1141        > + Send;
1142    fn r#drop_ipv6_membership(
1143        &self,
1144        membership: &fidl_fuchsia_posix_socket::Ipv6MulticastMembership,
1145    ) -> Self::DropIpv6MembershipResponseFut;
1146    type SetIpv6MulticastInterfaceResponseFut: std::future::Future<
1147            Output = Result<
1148                fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastInterfaceResult,
1149                fidl::Error,
1150            >,
1151        > + Send;
1152    fn r#set_ipv6_multicast_interface(
1153        &self,
1154        value: u64,
1155    ) -> Self::SetIpv6MulticastInterfaceResponseFut;
1156    type GetIpv6MulticastInterfaceResponseFut: std::future::Future<
1157            Output = Result<
1158                fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastInterfaceResult,
1159                fidl::Error,
1160            >,
1161        > + Send;
1162    fn r#get_ipv6_multicast_interface(&self) -> Self::GetIpv6MulticastInterfaceResponseFut;
1163    type SetIpv6UnicastHopsResponseFut: std::future::Future<
1164            Output = Result<
1165                fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6UnicastHopsResult,
1166                fidl::Error,
1167            >,
1168        > + Send;
1169    fn r#set_ipv6_unicast_hops(
1170        &self,
1171        value: &fidl_fuchsia_posix_socket::OptionalUint8,
1172    ) -> Self::SetIpv6UnicastHopsResponseFut;
1173    type GetIpv6UnicastHopsResponseFut: std::future::Future<
1174            Output = Result<
1175                fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6UnicastHopsResult,
1176                fidl::Error,
1177            >,
1178        > + Send;
1179    fn r#get_ipv6_unicast_hops(&self) -> Self::GetIpv6UnicastHopsResponseFut;
1180    type SetIpv6ReceiveHopLimitResponseFut: std::future::Future<
1181            Output = Result<
1182                fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
1183                fidl::Error,
1184            >,
1185        > + Send;
1186    fn r#set_ipv6_receive_hop_limit(&self, value: bool) -> Self::SetIpv6ReceiveHopLimitResponseFut;
1187    type GetIpv6ReceiveHopLimitResponseFut: std::future::Future<
1188            Output = Result<
1189                fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
1190                fidl::Error,
1191            >,
1192        > + Send;
1193    fn r#get_ipv6_receive_hop_limit(&self) -> Self::GetIpv6ReceiveHopLimitResponseFut;
1194    type SetIpv6MulticastHopsResponseFut: std::future::Future<
1195            Output = Result<
1196                fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastHopsResult,
1197                fidl::Error,
1198            >,
1199        > + Send;
1200    fn r#set_ipv6_multicast_hops(
1201        &self,
1202        value: &fidl_fuchsia_posix_socket::OptionalUint8,
1203    ) -> Self::SetIpv6MulticastHopsResponseFut;
1204    type GetIpv6MulticastHopsResponseFut: std::future::Future<
1205            Output = Result<
1206                fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastHopsResult,
1207                fidl::Error,
1208            >,
1209        > + Send;
1210    fn r#get_ipv6_multicast_hops(&self) -> Self::GetIpv6MulticastHopsResponseFut;
1211    type SetIpv6MulticastLoopbackResponseFut: std::future::Future<
1212            Output = Result<
1213                fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastLoopbackResult,
1214                fidl::Error,
1215            >,
1216        > + Send;
1217    fn r#set_ipv6_multicast_loopback(
1218        &self,
1219        value: bool,
1220    ) -> Self::SetIpv6MulticastLoopbackResponseFut;
1221    type GetIpv6MulticastLoopbackResponseFut: std::future::Future<
1222            Output = Result<
1223                fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastLoopbackResult,
1224                fidl::Error,
1225            >,
1226        > + Send;
1227    fn r#get_ipv6_multicast_loopback(&self) -> Self::GetIpv6MulticastLoopbackResponseFut;
1228    type SetIpv6OnlyResponseFut: std::future::Future<
1229            Output = Result<
1230                fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6OnlyResult,
1231                fidl::Error,
1232            >,
1233        > + Send;
1234    fn r#set_ipv6_only(&self, value: bool) -> Self::SetIpv6OnlyResponseFut;
1235    type GetIpv6OnlyResponseFut: std::future::Future<
1236            Output = Result<
1237                fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6OnlyResult,
1238                fidl::Error,
1239            >,
1240        > + Send;
1241    fn r#get_ipv6_only(&self) -> Self::GetIpv6OnlyResponseFut;
1242    type SetIpv6ReceiveTrafficClassResponseFut: std::future::Future<
1243            Output = Result<
1244                fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
1245                fidl::Error,
1246            >,
1247        > + Send;
1248    fn r#set_ipv6_receive_traffic_class(
1249        &self,
1250        value: bool,
1251    ) -> Self::SetIpv6ReceiveTrafficClassResponseFut;
1252    type GetIpv6ReceiveTrafficClassResponseFut: std::future::Future<
1253            Output = Result<
1254                fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
1255                fidl::Error,
1256            >,
1257        > + Send;
1258    fn r#get_ipv6_receive_traffic_class(&self) -> Self::GetIpv6ReceiveTrafficClassResponseFut;
1259    type SetIpv6TrafficClassResponseFut: std::future::Future<
1260            Output = Result<
1261                fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6TrafficClassResult,
1262                fidl::Error,
1263            >,
1264        > + Send;
1265    fn r#set_ipv6_traffic_class(
1266        &self,
1267        value: &fidl_fuchsia_posix_socket::OptionalUint8,
1268    ) -> Self::SetIpv6TrafficClassResponseFut;
1269    type GetIpv6TrafficClassResponseFut: std::future::Future<
1270            Output = Result<
1271                fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6TrafficClassResult,
1272                fidl::Error,
1273            >,
1274        > + Send;
1275    fn r#get_ipv6_traffic_class(&self) -> Self::GetIpv6TrafficClassResponseFut;
1276    type SetIpv6ReceivePacketInfoResponseFut: std::future::Future<
1277            Output = Result<
1278                fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
1279                fidl::Error,
1280            >,
1281        > + Send;
1282    fn r#set_ipv6_receive_packet_info(
1283        &self,
1284        value: bool,
1285    ) -> Self::SetIpv6ReceivePacketInfoResponseFut;
1286    type GetIpv6ReceivePacketInfoResponseFut: std::future::Future<
1287            Output = Result<
1288                fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
1289                fidl::Error,
1290            >,
1291        > + Send;
1292    fn r#get_ipv6_receive_packet_info(&self) -> Self::GetIpv6ReceivePacketInfoResponseFut;
1293    type GetOriginalDestinationResponseFut: std::future::Future<
1294            Output = Result<
1295                fidl_fuchsia_posix_socket::BaseNetworkSocketGetOriginalDestinationResult,
1296                fidl::Error,
1297            >,
1298        > + Send;
1299    fn r#get_original_destination(&self) -> Self::GetOriginalDestinationResponseFut;
1300    type DescribeResponseFut: std::future::Future<Output = Result<SocketDescribeResponse, fidl::Error>>
1301        + Send;
1302    fn r#describe(&self) -> Self::DescribeResponseFut;
1303    type RecvMsgResponseFut: std::future::Future<Output = Result<SocketRecvMsgResult, fidl::Error>>
1304        + Send;
1305    fn r#recv_msg(
1306        &self,
1307        want_addr: bool,
1308        data_len: u32,
1309        want_control: bool,
1310        flags: fidl_fuchsia_posix_socket::RecvMsgFlags,
1311    ) -> Self::RecvMsgResponseFut;
1312    type SendMsgResponseFut: std::future::Future<Output = Result<SocketSendMsgResult, fidl::Error>>
1313        + Send;
1314    fn r#send_msg(
1315        &self,
1316        addr: Option<&fidl_fuchsia_net::SocketAddress>,
1317        data: &[u8],
1318        control: &fidl_fuchsia_posix_socket::NetworkSocketSendControlData,
1319        flags: fidl_fuchsia_posix_socket::SendMsgFlags,
1320    ) -> Self::SendMsgResponseFut;
1321    type GetInfoResponseFut: std::future::Future<Output = Result<SocketGetInfoResult, fidl::Error>>
1322        + Send;
1323    fn r#get_info(&self) -> Self::GetInfoResponseFut;
1324    type SetIpHeaderIncludedResponseFut: std::future::Future<Output = Result<SocketSetIpHeaderIncludedResult, fidl::Error>>
1325        + Send;
1326    fn r#set_ip_header_included(&self, value: bool) -> Self::SetIpHeaderIncludedResponseFut;
1327    type GetIpHeaderIncludedResponseFut: std::future::Future<Output = Result<SocketGetIpHeaderIncludedResult, fidl::Error>>
1328        + Send;
1329    fn r#get_ip_header_included(&self) -> Self::GetIpHeaderIncludedResponseFut;
1330    type SetIcmpv6FilterResponseFut: std::future::Future<Output = Result<SocketSetIcmpv6FilterResult, fidl::Error>>
1331        + Send;
1332    fn r#set_icmpv6_filter(&self, filter: &Icmpv6Filter) -> Self::SetIcmpv6FilterResponseFut;
1333    type GetIcmpv6FilterResponseFut: std::future::Future<Output = Result<SocketGetIcmpv6FilterResult, fidl::Error>>
1334        + Send;
1335    fn r#get_icmpv6_filter(&self) -> Self::GetIcmpv6FilterResponseFut;
1336    type SetIpv6ChecksumResponseFut: std::future::Future<Output = Result<SocketSetIpv6ChecksumResult, fidl::Error>>
1337        + Send;
1338    fn r#set_ipv6_checksum(
1339        &self,
1340        config: &Ipv6ChecksumConfiguration,
1341    ) -> Self::SetIpv6ChecksumResponseFut;
1342    type GetIpv6ChecksumResponseFut: std::future::Future<Output = Result<SocketGetIpv6ChecksumResult, fidl::Error>>
1343        + Send;
1344    fn r#get_ipv6_checksum(&self) -> Self::GetIpv6ChecksumResponseFut;
1345}
1346#[derive(Debug)]
1347#[cfg(target_os = "fuchsia")]
1348pub struct SocketSynchronousProxy {
1349    client: fidl::client::sync::Client,
1350}
1351
1352#[cfg(target_os = "fuchsia")]
1353impl fidl::endpoints::SynchronousProxy for SocketSynchronousProxy {
1354    type Proxy = SocketProxy;
1355    type Protocol = SocketMarker;
1356
1357    fn from_channel(inner: fidl::Channel) -> Self {
1358        Self::new(inner)
1359    }
1360
1361    fn into_channel(self) -> fidl::Channel {
1362        self.client.into_channel()
1363    }
1364
1365    fn as_channel(&self) -> &fidl::Channel {
1366        self.client.as_channel()
1367    }
1368}
1369
1370#[cfg(target_os = "fuchsia")]
1371impl SocketSynchronousProxy {
1372    pub fn new(channel: fidl::Channel) -> Self {
1373        let protocol_name = <SocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
1374        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
1375    }
1376
1377    pub fn into_channel(self) -> fidl::Channel {
1378        self.client.into_channel()
1379    }
1380
1381    /// Waits until an event arrives and returns it. It is safe for other
1382    /// threads to make concurrent requests while waiting for an event.
1383    pub fn wait_for_event(
1384        &self,
1385        deadline: zx::MonotonicInstant,
1386    ) -> Result<SocketEvent, fidl::Error> {
1387        SocketEvent::decode(self.client.wait_for_event(deadline)?)
1388    }
1389
1390    pub fn r#clone(
1391        &self,
1392        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
1393    ) -> Result<(), fidl::Error> {
1394        self.client.send::<fidl_fuchsia_unknown::CloneableCloneRequest>(
1395            (request,),
1396            0x20d8a7aba2168a79,
1397            fidl::encoding::DynamicFlags::empty(),
1398        )
1399    }
1400
1401    /// Terminates the connection.
1402    ///
1403    /// After calling `Close`, the client must not send any other requests.
1404    ///
1405    /// Servers, after sending the status response, should close the connection
1406    /// regardless of status and without sending an epitaph.
1407    ///
1408    /// Closing the client end of the channel should be semantically equivalent
1409    /// to calling `Close` without knowing when the close has completed or its
1410    /// status.
1411    pub fn r#close(
1412        &self,
1413        ___deadline: zx::MonotonicInstant,
1414    ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
1415        let _response = self.client.send_query::<
1416            fidl::encoding::EmptyPayload,
1417            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
1418        >(
1419            (),
1420            0x5ac5d459ad7f657e,
1421            fidl::encoding::DynamicFlags::empty(),
1422            ___deadline,
1423        )?;
1424        Ok(_response.map(|x| x))
1425    }
1426
1427    pub fn r#query(&self, ___deadline: zx::MonotonicInstant) -> Result<Vec<u8>, fidl::Error> {
1428        let _response = self.client.send_query::<
1429            fidl::encoding::EmptyPayload,
1430            fidl_fuchsia_unknown::QueryableQueryResponse,
1431        >(
1432            (),
1433            0x2658edee9decfc06,
1434            fidl::encoding::DynamicFlags::empty(),
1435            ___deadline,
1436        )?;
1437        Ok(_response.protocol)
1438    }
1439
1440    /// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
1441    pub fn r#set_reuse_address(
1442        &self,
1443        mut value: bool,
1444        ___deadline: zx::MonotonicInstant,
1445    ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetReuseAddressResult, fidl::Error> {
1446        let _response = self.client.send_query::<
1447            fidl_fuchsia_posix_socket::BaseSocketSetReuseAddressRequest,
1448            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1449        >(
1450            (value,),
1451            0x1fd74ee8b9a4a876,
1452            fidl::encoding::DynamicFlags::empty(),
1453            ___deadline,
1454        )?;
1455        Ok(_response.map(|x| x))
1456    }
1457
1458    /// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
1459    pub fn r#get_reuse_address(
1460        &self,
1461        ___deadline: zx::MonotonicInstant,
1462    ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetReuseAddressResult, fidl::Error> {
1463        let _response = self
1464            .client
1465            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1466                fidl_fuchsia_posix_socket::BaseSocketGetReuseAddressResponse,
1467                fidl_fuchsia_posix::Errno,
1468            >>(
1469                (), 0x67b7206b8d1bc0a5, fidl::encoding::DynamicFlags::empty(), ___deadline
1470            )?;
1471        Ok(_response.map(|x| x.value))
1472    }
1473
1474    /// Get `SOL_SOCKET` -> `SO_ERROR`.
1475    /// Returns the last error if there is an error set on the socket.
1476    pub fn r#get_error(
1477        &self,
1478        ___deadline: zx::MonotonicInstant,
1479    ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetErrorResult, fidl::Error> {
1480        let _response =
1481            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1482                fidl::encoding::EmptyStruct,
1483                fidl_fuchsia_posix::Errno,
1484            >>(
1485                (),
1486                0x5aad39b33e5f6ebb,
1487                fidl::encoding::DynamicFlags::empty(),
1488                ___deadline,
1489            )?;
1490        Ok(_response.map(|x| x))
1491    }
1492
1493    /// Set `SOL_SOCKET` -> `SO_BROADCAST`.
1494    pub fn r#set_broadcast(
1495        &self,
1496        mut value: bool,
1497        ___deadline: zx::MonotonicInstant,
1498    ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetBroadcastResult, fidl::Error> {
1499        let _response = self.client.send_query::<
1500            fidl_fuchsia_posix_socket::BaseSocketSetBroadcastRequest,
1501            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1502        >(
1503            (value,),
1504            0x6023e081ce3cd947,
1505            fidl::encoding::DynamicFlags::empty(),
1506            ___deadline,
1507        )?;
1508        Ok(_response.map(|x| x))
1509    }
1510
1511    /// Get `SOL_SOCKET` -> `SO_BROADCAST`.
1512    pub fn r#get_broadcast(
1513        &self,
1514        ___deadline: zx::MonotonicInstant,
1515    ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetBroadcastResult, fidl::Error> {
1516        let _response = self
1517            .client
1518            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1519                fidl_fuchsia_posix_socket::BaseSocketGetBroadcastResponse,
1520                fidl_fuchsia_posix::Errno,
1521            >>(
1522                (), 0x68796fc556f9780d, fidl::encoding::DynamicFlags::empty(), ___deadline
1523            )?;
1524        Ok(_response.map(|x| x.value))
1525    }
1526
1527    /// Set `SOL_SOCKET` -> `SO_SNDBUF`.
1528    pub fn r#set_send_buffer(
1529        &self,
1530        mut value_bytes: u64,
1531        ___deadline: zx::MonotonicInstant,
1532    ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetSendBufferResult, fidl::Error> {
1533        let _response = self.client.send_query::<
1534            fidl_fuchsia_posix_socket::BaseSocketSetSendBufferRequest,
1535            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1536        >(
1537            (value_bytes,),
1538            0x756eac32d73a7a70,
1539            fidl::encoding::DynamicFlags::empty(),
1540            ___deadline,
1541        )?;
1542        Ok(_response.map(|x| x))
1543    }
1544
1545    /// Get `SOL_SOCKET` -> `SO_SNDBUF`.
1546    pub fn r#get_send_buffer(
1547        &self,
1548        ___deadline: zx::MonotonicInstant,
1549    ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetSendBufferResult, fidl::Error> {
1550        let _response = self
1551            .client
1552            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1553                fidl_fuchsia_posix_socket::BaseSocketGetSendBufferResponse,
1554                fidl_fuchsia_posix::Errno,
1555            >>(
1556                (), 0x78a52fd9c7b2410b, fidl::encoding::DynamicFlags::empty(), ___deadline
1557            )?;
1558        Ok(_response.map(|x| x.value_bytes))
1559    }
1560
1561    /// Set `SOL_SOCKET` -> `SO_RCVBUF`.
1562    pub fn r#set_receive_buffer(
1563        &self,
1564        mut value_bytes: u64,
1565        ___deadline: zx::MonotonicInstant,
1566    ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetReceiveBufferResult, fidl::Error> {
1567        let _response = self.client.send_query::<
1568            fidl_fuchsia_posix_socket::BaseSocketSetReceiveBufferRequest,
1569            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1570        >(
1571            (value_bytes,),
1572            0x6b0cf2f1919c7001,
1573            fidl::encoding::DynamicFlags::empty(),
1574            ___deadline,
1575        )?;
1576        Ok(_response.map(|x| x))
1577    }
1578
1579    /// Get `SOL_SOCKET` -> `SO_RCVBUF`.
1580    pub fn r#get_receive_buffer(
1581        &self,
1582        ___deadline: zx::MonotonicInstant,
1583    ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetReceiveBufferResult, fidl::Error> {
1584        let _response = self
1585            .client
1586            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1587                fidl_fuchsia_posix_socket::BaseSocketGetReceiveBufferResponse,
1588                fidl_fuchsia_posix::Errno,
1589            >>(
1590                (), 0x14c1a4b64f709e5c, fidl::encoding::DynamicFlags::empty(), ___deadline
1591            )?;
1592        Ok(_response.map(|x| x.value_bytes))
1593    }
1594
1595    /// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
1596    pub fn r#set_keep_alive(
1597        &self,
1598        mut value: bool,
1599        ___deadline: zx::MonotonicInstant,
1600    ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetKeepAliveResult, fidl::Error> {
1601        let _response = self.client.send_query::<
1602            fidl_fuchsia_posix_socket::BaseSocketSetKeepAliveRequest,
1603            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1604        >(
1605            (value,),
1606            0x572df8f0b920d2c7,
1607            fidl::encoding::DynamicFlags::empty(),
1608            ___deadline,
1609        )?;
1610        Ok(_response.map(|x| x))
1611    }
1612
1613    /// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
1614    pub fn r#get_keep_alive(
1615        &self,
1616        ___deadline: zx::MonotonicInstant,
1617    ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetKeepAliveResult, fidl::Error> {
1618        let _response = self
1619            .client
1620            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1621                fidl_fuchsia_posix_socket::BaseSocketGetKeepAliveResponse,
1622                fidl_fuchsia_posix::Errno,
1623            >>(
1624                (), 0x2dd29d3215f2c9d2, fidl::encoding::DynamicFlags::empty(), ___deadline
1625            )?;
1626        Ok(_response.map(|x| x.value))
1627    }
1628
1629    /// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
1630    pub fn r#set_out_of_band_inline(
1631        &self,
1632        mut value: bool,
1633        ___deadline: zx::MonotonicInstant,
1634    ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetOutOfBandInlineResult, fidl::Error> {
1635        let _response = self.client.send_query::<
1636            fidl_fuchsia_posix_socket::BaseSocketSetOutOfBandInlineRequest,
1637            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1638        >(
1639            (value,),
1640            0x3ecb49968bee439,
1641            fidl::encoding::DynamicFlags::empty(),
1642            ___deadline,
1643        )?;
1644        Ok(_response.map(|x| x))
1645    }
1646
1647    /// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
1648    pub fn r#get_out_of_band_inline(
1649        &self,
1650        ___deadline: zx::MonotonicInstant,
1651    ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetOutOfBandInlineResult, fidl::Error> {
1652        let _response = self
1653            .client
1654            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1655                fidl_fuchsia_posix_socket::BaseSocketGetOutOfBandInlineResponse,
1656                fidl_fuchsia_posix::Errno,
1657            >>(
1658                (), 0x348c1ab3aeca1745, fidl::encoding::DynamicFlags::empty(), ___deadline
1659            )?;
1660        Ok(_response.map(|x| x.value))
1661    }
1662
1663    /// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
1664    pub fn r#set_no_check(
1665        &self,
1666        mut value: bool,
1667        ___deadline: zx::MonotonicInstant,
1668    ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetNoCheckResult, fidl::Error> {
1669        let _response = self.client.send_query::<
1670            fidl_fuchsia_posix_socket::BaseSocketSetNoCheckRequest,
1671            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1672        >(
1673            (value,),
1674            0x6bbf00c53a4c78c2,
1675            fidl::encoding::DynamicFlags::empty(),
1676            ___deadline,
1677        )?;
1678        Ok(_response.map(|x| x))
1679    }
1680
1681    /// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
1682    pub fn r#get_no_check(
1683        &self,
1684        ___deadline: zx::MonotonicInstant,
1685    ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetNoCheckResult, fidl::Error> {
1686        let _response = self
1687            .client
1688            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1689                fidl_fuchsia_posix_socket::BaseSocketGetNoCheckResponse,
1690                fidl_fuchsia_posix::Errno,
1691            >>(
1692                (), 0x2cd4249286417694, fidl::encoding::DynamicFlags::empty(), ___deadline
1693            )?;
1694        Ok(_response.map(|x| x.value))
1695    }
1696
1697    /// Set `SOL_SOCKET` -> `SO_LINGER`.
1698    pub fn r#set_linger(
1699        &self,
1700        mut linger: bool,
1701        mut length_secs: u32,
1702        ___deadline: zx::MonotonicInstant,
1703    ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetLingerResult, fidl::Error> {
1704        let _response = self.client.send_query::<
1705            fidl_fuchsia_posix_socket::BaseSocketSetLingerRequest,
1706            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1707        >(
1708            (linger, length_secs,),
1709            0x45386351246e998e,
1710            fidl::encoding::DynamicFlags::empty(),
1711            ___deadline,
1712        )?;
1713        Ok(_response.map(|x| x))
1714    }
1715
1716    /// Get `SOL_SOCKET` -> `SO_LINGER`.
1717    pub fn r#get_linger(
1718        &self,
1719        ___deadline: zx::MonotonicInstant,
1720    ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetLingerResult, fidl::Error> {
1721        let _response = self
1722            .client
1723            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1724                fidl_fuchsia_posix_socket::BaseSocketGetLingerResponse,
1725                fidl_fuchsia_posix::Errno,
1726            >>(
1727                (), 0x48eb20fc5ccb0e45, fidl::encoding::DynamicFlags::empty(), ___deadline
1728            )?;
1729        Ok(_response.map(|x| (x.linger, x.length_secs)))
1730    }
1731
1732    /// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
1733    pub fn r#set_reuse_port(
1734        &self,
1735        mut value: bool,
1736        ___deadline: zx::MonotonicInstant,
1737    ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetReusePortResult, fidl::Error> {
1738        let _response = self.client.send_query::<
1739            fidl_fuchsia_posix_socket::BaseSocketSetReusePortRequest,
1740            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1741        >(
1742            (value,),
1743            0x24dd3e5cb36d9ccb,
1744            fidl::encoding::DynamicFlags::empty(),
1745            ___deadline,
1746        )?;
1747        Ok(_response.map(|x| x))
1748    }
1749
1750    /// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
1751    pub fn r#get_reuse_port(
1752        &self,
1753        ___deadline: zx::MonotonicInstant,
1754    ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetReusePortResult, fidl::Error> {
1755        let _response = self
1756            .client
1757            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1758                fidl_fuchsia_posix_socket::BaseSocketGetReusePortResponse,
1759                fidl_fuchsia_posix::Errno,
1760            >>(
1761                (), 0x7a112c1ab54ff828, fidl::encoding::DynamicFlags::empty(), ___deadline
1762            )?;
1763        Ok(_response.map(|x| x.value))
1764    }
1765
1766    /// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
1767    pub fn r#get_accept_conn(
1768        &self,
1769        ___deadline: zx::MonotonicInstant,
1770    ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetAcceptConnResult, fidl::Error> {
1771        let _response = self
1772            .client
1773            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1774                fidl_fuchsia_posix_socket::BaseSocketGetAcceptConnResponse,
1775                fidl_fuchsia_posix::Errno,
1776            >>(
1777                (), 0x67ce6db6c2ec8966, fidl::encoding::DynamicFlags::empty(), ___deadline
1778            )?;
1779        Ok(_response.map(|x| x.value))
1780    }
1781
1782    /// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
1783    pub fn r#set_bind_to_device(
1784        &self,
1785        mut value: &str,
1786        ___deadline: zx::MonotonicInstant,
1787    ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetBindToDeviceResult, fidl::Error> {
1788        let _response = self.client.send_query::<
1789            fidl_fuchsia_posix_socket::BaseSocketSetBindToDeviceRequest,
1790            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1791        >(
1792            (value,),
1793            0x2118b483f28aafc4,
1794            fidl::encoding::DynamicFlags::empty(),
1795            ___deadline,
1796        )?;
1797        Ok(_response.map(|x| x))
1798    }
1799
1800    /// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
1801    pub fn r#get_bind_to_device(
1802        &self,
1803        ___deadline: zx::MonotonicInstant,
1804    ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetBindToDeviceResult, fidl::Error> {
1805        let _response = self
1806            .client
1807            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1808                fidl_fuchsia_posix_socket::BaseSocketGetBindToDeviceResponse,
1809                fidl_fuchsia_posix::Errno,
1810            >>(
1811                (), 0x1ab1fbf0ef7906c8, fidl::encoding::DynamicFlags::empty(), ___deadline
1812            )?;
1813        Ok(_response.map(|x| x.value))
1814    }
1815
1816    /// Set `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
1817    /// If `value` is 0, this clears the bound interface.
1818    pub fn r#set_bind_to_interface_index(
1819        &self,
1820        mut value: u64,
1821        ___deadline: zx::MonotonicInstant,
1822    ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetBindToInterfaceIndexResult, fidl::Error>
1823    {
1824        let _response = self.client.send_query::<
1825            fidl_fuchsia_posix_socket::BaseSocketSetBindToInterfaceIndexRequest,
1826            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1827        >(
1828            (value,),
1829            0x6e387a0def00821,
1830            fidl::encoding::DynamicFlags::empty(),
1831            ___deadline,
1832        )?;
1833        Ok(_response.map(|x| x))
1834    }
1835
1836    /// Get `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
1837    pub fn r#get_bind_to_interface_index(
1838        &self,
1839        ___deadline: zx::MonotonicInstant,
1840    ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetBindToInterfaceIndexResult, fidl::Error>
1841    {
1842        let _response = self
1843            .client
1844            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1845                fidl_fuchsia_posix_socket::BaseSocketGetBindToInterfaceIndexResponse,
1846                fidl_fuchsia_posix::Errno,
1847            >>(
1848                (), 0x59c31dd3e3078295, fidl::encoding::DynamicFlags::empty(), ___deadline
1849            )?;
1850        Ok(_response.map(|x| x.value))
1851    }
1852
1853    /// Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
1854    pub fn r#set_timestamp(
1855        &self,
1856        mut value: fidl_fuchsia_posix_socket::TimestampOption,
1857        ___deadline: zx::MonotonicInstant,
1858    ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetTimestampResult, fidl::Error> {
1859        let _response = self.client.send_query::<
1860            fidl_fuchsia_posix_socket::BaseSocketSetTimestampRequest,
1861            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1862        >(
1863            (value,),
1864            0x285d6516c263d839,
1865            fidl::encoding::DynamicFlags::empty(),
1866            ___deadline,
1867        )?;
1868        Ok(_response.map(|x| x))
1869    }
1870
1871    /// Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
1872    pub fn r#get_timestamp(
1873        &self,
1874        ___deadline: zx::MonotonicInstant,
1875    ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetTimestampResult, fidl::Error> {
1876        let _response = self
1877            .client
1878            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1879                fidl_fuchsia_posix_socket::BaseSocketGetTimestampResponse,
1880                fidl_fuchsia_posix::Errno,
1881            >>(
1882                (), 0x49f2fffbbcc2bd27, fidl::encoding::DynamicFlags::empty(), ___deadline
1883            )?;
1884        Ok(_response.map(|x| x.value))
1885    }
1886
1887    /// Like setting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
1888    /// unlike the standard SO_MARK, this API has multiple mark domains and each
1889    /// mark can be set independently in each domain.
1890    pub fn r#set_mark(
1891        &self,
1892        mut domain: fidl_fuchsia_net::MarkDomain,
1893        mut mark: &fidl_fuchsia_posix_socket::OptionalUint32,
1894        ___deadline: zx::MonotonicInstant,
1895    ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetMarkResult, fidl::Error> {
1896        let _response = self.client.send_query::<
1897            fidl_fuchsia_posix_socket::BaseSocketSetMarkRequest,
1898            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1899        >(
1900            (domain, mark,),
1901            0x6ead6de09f653236,
1902            fidl::encoding::DynamicFlags::empty(),
1903            ___deadline,
1904        )?;
1905        Ok(_response.map(|x| x))
1906    }
1907
1908    /// Like getting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
1909    /// unlike the standard SO_MARK, this API has multiple mark domains and each
1910    /// mark can be retrieved independently in each domain.
1911    pub fn r#get_mark(
1912        &self,
1913        mut domain: fidl_fuchsia_net::MarkDomain,
1914        ___deadline: zx::MonotonicInstant,
1915    ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetMarkResult, fidl::Error> {
1916        let _response = self.client.send_query::<
1917            fidl_fuchsia_posix_socket::BaseSocketGetMarkRequest,
1918            fidl::encoding::ResultType<fidl_fuchsia_posix_socket::BaseSocketGetMarkResponse, fidl_fuchsia_posix::Errno>,
1919        >(
1920            (domain,),
1921            0x57a2752c61d93d47,
1922            fidl::encoding::DynamicFlags::empty(),
1923            ___deadline,
1924        )?;
1925        Ok(_response.map(|x| x.mark))
1926    }
1927
1928    /// Get `SOL_SOCKET` -> `SO_COOKIE`.
1929    pub fn r#get_cookie(
1930        &self,
1931        ___deadline: zx::MonotonicInstant,
1932    ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetCookieResult, fidl::Error> {
1933        let _response = self
1934            .client
1935            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1936                fidl_fuchsia_posix_socket::BaseSocketGetCookieResponse,
1937                fidl_fuchsia_posix::Errno,
1938            >>(
1939                (), 0x2c2f47fd8f924e52, fidl::encoding::DynamicFlags::empty(), ___deadline
1940            )?;
1941        Ok(_response.map(|x| x.value))
1942    }
1943
1944    /// Sets the local address used for the socket.
1945    pub fn r#bind(
1946        &self,
1947        mut addr: &fidl_fuchsia_net::SocketAddress,
1948        ___deadline: zx::MonotonicInstant,
1949    ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketBindResult, fidl::Error> {
1950        let _response = self.client.send_query::<
1951            fidl_fuchsia_posix_socket::BaseNetworkSocketBindRequest,
1952            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1953        >(
1954            (addr,),
1955            0x4bc6400ae92125d,
1956            fidl::encoding::DynamicFlags::empty(),
1957            ___deadline,
1958        )?;
1959        Ok(_response.map(|x| x))
1960    }
1961
1962    /// Initiates a connection to a remote address.
1963    pub fn r#connect(
1964        &self,
1965        mut addr: &fidl_fuchsia_net::SocketAddress,
1966        ___deadline: zx::MonotonicInstant,
1967    ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketConnectResult, fidl::Error> {
1968        let _response = self.client.send_query::<
1969            fidl_fuchsia_posix_socket::BaseNetworkSocketConnectRequest,
1970            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1971        >(
1972            (addr,),
1973            0x5f05f19bfdd38871,
1974            fidl::encoding::DynamicFlags::empty(),
1975            ___deadline,
1976        )?;
1977        Ok(_response.map(|x| x))
1978    }
1979
1980    /// Clears connection information from this socket.
1981    pub fn r#disconnect(
1982        &self,
1983        ___deadline: zx::MonotonicInstant,
1984    ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketDisconnectResult, fidl::Error> {
1985        let _response =
1986            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1987                fidl::encoding::EmptyStruct,
1988                fidl_fuchsia_posix::Errno,
1989            >>(
1990                (),
1991                0x74e63b91f7b29b2,
1992                fidl::encoding::DynamicFlags::empty(),
1993                ___deadline,
1994            )?;
1995        Ok(_response.map(|x| x))
1996    }
1997
1998    /// Retrieves the local socket address.
1999    pub fn r#get_sock_name(
2000        &self,
2001        ___deadline: zx::MonotonicInstant,
2002    ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetSockNameResult, fidl::Error> {
2003        let _response = self
2004            .client
2005            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2006                fidl_fuchsia_posix_socket::BaseNetworkSocketGetSockNameResponse,
2007                fidl_fuchsia_posix::Errno,
2008            >>(
2009                (), 0x475f23f84a1a4f85, fidl::encoding::DynamicFlags::empty(), ___deadline
2010            )?;
2011        Ok(_response.map(|x| x.addr))
2012    }
2013
2014    /// Retrieves the remote socket address.
2015    pub fn r#get_peer_name(
2016        &self,
2017        ___deadline: zx::MonotonicInstant,
2018    ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetPeerNameResult, fidl::Error> {
2019        let _response = self
2020            .client
2021            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2022                fidl_fuchsia_posix_socket::BaseNetworkSocketGetPeerNameResponse,
2023                fidl_fuchsia_posix::Errno,
2024            >>(
2025                (), 0x1ffecf4bd5b6432e, fidl::encoding::DynamicFlags::empty(), ___deadline
2026            )?;
2027        Ok(_response.map(|x| x.addr))
2028    }
2029
2030    /// Shuts down part of the socket.
2031    pub fn r#shutdown(
2032        &self,
2033        mut mode: fidl_fuchsia_posix_socket::ShutdownMode,
2034        ___deadline: zx::MonotonicInstant,
2035    ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketShutdownResult, fidl::Error> {
2036        let _response = self.client.send_query::<
2037            fidl_fuchsia_posix_socket::BaseNetworkSocketShutdownRequest,
2038            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2039        >(
2040            (mode,),
2041            0x247f38b6db68c336,
2042            fidl::encoding::DynamicFlags::empty(),
2043            ___deadline,
2044        )?;
2045        Ok(_response.map(|x| x))
2046    }
2047
2048    /// Set `SOL_IP` -> `IP_TOS`.
2049    pub fn r#set_ip_type_of_service(
2050        &self,
2051        mut value: u8,
2052        ___deadline: zx::MonotonicInstant,
2053    ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error>
2054    {
2055        let _response = self.client.send_query::<
2056            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTypeOfServiceRequest,
2057            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2058        >(
2059            (value,),
2060            0x995c600475b6d46,
2061            fidl::encoding::DynamicFlags::empty(),
2062            ___deadline,
2063        )?;
2064        Ok(_response.map(|x| x))
2065    }
2066
2067    /// Get `SOL_IP` -> `IP_TOS`.
2068    pub fn r#get_ip_type_of_service(
2069        &self,
2070        ___deadline: zx::MonotonicInstant,
2071    ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error>
2072    {
2073        let _response = self
2074            .client
2075            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2076                fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTypeOfServiceResponse,
2077                fidl_fuchsia_posix::Errno,
2078            >>(
2079                (), 0x3814a04259f75fcb, fidl::encoding::DynamicFlags::empty(), ___deadline
2080            )?;
2081        Ok(_response.map(|x| x.value))
2082    }
2083
2084    /// Set `SOL_IP` -> `IP_TTL`.
2085    pub fn r#set_ip_ttl(
2086        &self,
2087        mut value: &fidl_fuchsia_posix_socket::OptionalUint8,
2088        ___deadline: zx::MonotonicInstant,
2089    ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTtlResult, fidl::Error> {
2090        let _response = self.client.send_query::<
2091            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTtlRequest,
2092            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2093        >(
2094            (value,),
2095            0x29e2424b433ae1ef,
2096            fidl::encoding::DynamicFlags::empty(),
2097            ___deadline,
2098        )?;
2099        Ok(_response.map(|x| x))
2100    }
2101
2102    /// Get `SOL_IP` -> `IP_TTL`.
2103    pub fn r#get_ip_ttl(
2104        &self,
2105        ___deadline: zx::MonotonicInstant,
2106    ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTtlResult, fidl::Error> {
2107        let _response = self
2108            .client
2109            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2110                fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTtlResponse,
2111                fidl_fuchsia_posix::Errno,
2112            >>(
2113                (), 0x47e47fa1f24da471, fidl::encoding::DynamicFlags::empty(), ___deadline
2114            )?;
2115        Ok(_response.map(|x| x.value))
2116    }
2117
2118    /// Set `SOL_IP` -> `IP_PKTINFO`.
2119    pub fn r#set_ip_packet_info(
2120        &self,
2121        mut value: bool,
2122        ___deadline: zx::MonotonicInstant,
2123    ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpPacketInfoResult, fidl::Error>
2124    {
2125        let _response = self.client.send_query::<
2126            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpPacketInfoRequest,
2127            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2128        >(
2129            (value,),
2130            0x392d16bee20c0e16,
2131            fidl::encoding::DynamicFlags::empty(),
2132            ___deadline,
2133        )?;
2134        Ok(_response.map(|x| x))
2135    }
2136
2137    /// Get `SOL_IP` -> `IP_PKTINFO`.
2138    pub fn r#get_ip_packet_info(
2139        &self,
2140        ___deadline: zx::MonotonicInstant,
2141    ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpPacketInfoResult, fidl::Error>
2142    {
2143        let _response = self
2144            .client
2145            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2146                fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpPacketInfoResponse,
2147                fidl_fuchsia_posix::Errno,
2148            >>(
2149                (), 0x54b505f242280740, fidl::encoding::DynamicFlags::empty(), ___deadline
2150            )?;
2151        Ok(_response.map(|x| x.value))
2152    }
2153
2154    /// Set `SOL_IP` -> `IP_RECVTOS`.
2155    pub fn r#set_ip_receive_type_of_service(
2156        &self,
2157        mut value: bool,
2158        ___deadline: zx::MonotonicInstant,
2159    ) -> Result<
2160        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
2161        fidl::Error,
2162    > {
2163        let _response = self.client.send_query::<
2164            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveTypeOfServiceRequest,
2165            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2166        >(
2167            (value,),
2168            0x6c4f6714995f84ef,
2169            fidl::encoding::DynamicFlags::empty(),
2170            ___deadline,
2171        )?;
2172        Ok(_response.map(|x| x))
2173    }
2174
2175    /// Get `SOL_IP` -> `IP_RECVTOS`.
2176    pub fn r#get_ip_receive_type_of_service(
2177        &self,
2178        ___deadline: zx::MonotonicInstant,
2179    ) -> Result<
2180        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
2181        fidl::Error,
2182    > {
2183        let _response = self
2184            .client
2185            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2186                fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
2187                fidl_fuchsia_posix::Errno,
2188            >>(
2189                (), 0x4158ba7dc2795960, fidl::encoding::DynamicFlags::empty(), ___deadline
2190            )?;
2191        Ok(_response.map(|x| x.value))
2192    }
2193
2194    /// Set `SOL_IP` -> `IP_RECVTTL`.
2195    pub fn r#set_ip_receive_ttl(
2196        &self,
2197        mut value: bool,
2198        ___deadline: zx::MonotonicInstant,
2199    ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error>
2200    {
2201        let _response = self.client.send_query::<
2202            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveTtlRequest,
2203            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2204        >(
2205            (value,),
2206            0x46f15be0ce0ab82b,
2207            fidl::encoding::DynamicFlags::empty(),
2208            ___deadline,
2209        )?;
2210        Ok(_response.map(|x| x))
2211    }
2212
2213    /// Get `SOL_IP` -> `IP_RECVTTL`.
2214    pub fn r#get_ip_receive_ttl(
2215        &self,
2216        ___deadline: zx::MonotonicInstant,
2217    ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error>
2218    {
2219        let _response = self
2220            .client
2221            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2222                fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveTtlResponse,
2223                fidl_fuchsia_posix::Errno,
2224            >>(
2225                (), 0x678ddd5a5dfa2eb5, fidl::encoding::DynamicFlags::empty(), ___deadline
2226            )?;
2227        Ok(_response.map(|x| x.value))
2228    }
2229
2230    /// Set `SOL_IP` -> `IP_MULTICAST_IF`.
2231    pub fn r#set_ip_multicast_interface(
2232        &self,
2233        mut iface: u64,
2234        mut address: &fidl_fuchsia_net::Ipv4Address,
2235        ___deadline: zx::MonotonicInstant,
2236    ) -> Result<
2237        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastInterfaceResult,
2238        fidl::Error,
2239    > {
2240        let _response = self.client.send_query::<
2241            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastInterfaceRequest,
2242            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2243        >(
2244            (iface, address,),
2245            0x752fbfa9b12befe,
2246            fidl::encoding::DynamicFlags::empty(),
2247            ___deadline,
2248        )?;
2249        Ok(_response.map(|x| x))
2250    }
2251
2252    /// Get `SOL_IP` -> `IP_MULTICAST_IF`.
2253    pub fn r#get_ip_multicast_interface(
2254        &self,
2255        ___deadline: zx::MonotonicInstant,
2256    ) -> Result<
2257        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastInterfaceResult,
2258        fidl::Error,
2259    > {
2260        let _response = self
2261            .client
2262            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2263                fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastInterfaceResponse,
2264                fidl_fuchsia_posix::Errno,
2265            >>(
2266                (), 0x320bd14c4df046c4, fidl::encoding::DynamicFlags::empty(), ___deadline
2267            )?;
2268        Ok(_response.map(|x| x.value))
2269    }
2270
2271    /// Set `SOL_IP` -> `IP_MULTICAST_TTL`.
2272    pub fn r#set_ip_multicast_ttl(
2273        &self,
2274        mut value: &fidl_fuchsia_posix_socket::OptionalUint8,
2275        ___deadline: zx::MonotonicInstant,
2276    ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error>
2277    {
2278        let _response = self.client.send_query::<
2279            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastTtlRequest,
2280            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2281        >(
2282            (value,),
2283            0x63134d53772916a1,
2284            fidl::encoding::DynamicFlags::empty(),
2285            ___deadline,
2286        )?;
2287        Ok(_response.map(|x| x))
2288    }
2289
2290    /// Get `SOL_IP` -> `IP_MULTICAST_TTL`.
2291    pub fn r#get_ip_multicast_ttl(
2292        &self,
2293        ___deadline: zx::MonotonicInstant,
2294    ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error>
2295    {
2296        let _response = self
2297            .client
2298            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2299                fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastTtlResponse,
2300                fidl_fuchsia_posix::Errno,
2301            >>(
2302                (), 0x4665cd378f39e1a, fidl::encoding::DynamicFlags::empty(), ___deadline
2303            )?;
2304        Ok(_response.map(|x| x.value))
2305    }
2306
2307    /// Set `SOL_IP` -> `IP_MULTICAST_LOOP`.
2308    pub fn r#set_ip_multicast_loopback(
2309        &self,
2310        mut value: bool,
2311        ___deadline: zx::MonotonicInstant,
2312    ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error>
2313    {
2314        let _response = self.client.send_query::<
2315            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastLoopbackRequest,
2316            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2317        >(
2318            (value,),
2319            0x20c55c11f00943ea,
2320            fidl::encoding::DynamicFlags::empty(),
2321            ___deadline,
2322        )?;
2323        Ok(_response.map(|x| x))
2324    }
2325
2326    /// Get `SOL_IP` -> `IP_MULTICAST_LOOP`.
2327    pub fn r#get_ip_multicast_loopback(
2328        &self,
2329        ___deadline: zx::MonotonicInstant,
2330    ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error>
2331    {
2332        let _response = self
2333            .client
2334            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2335                fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastLoopbackResponse,
2336                fidl_fuchsia_posix::Errno,
2337            >>(
2338                (), 0x3b6b26ff558298f2, fidl::encoding::DynamicFlags::empty(), ___deadline
2339            )?;
2340        Ok(_response.map(|x| x.value))
2341    }
2342
2343    /// Set `SOL_IP` -> `IP_ADD_MEMBERSHIP`
2344    pub fn r#add_ip_membership(
2345        &self,
2346        mut membership: &fidl_fuchsia_posix_socket::IpMulticastMembership,
2347        ___deadline: zx::MonotonicInstant,
2348    ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketAddIpMembershipResult, fidl::Error>
2349    {
2350        let _response = self.client.send_query::<
2351            fidl_fuchsia_posix_socket::BaseNetworkSocketAddIpMembershipRequest,
2352            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2353        >(
2354            (membership,),
2355            0x76bc7df115a3b4d0,
2356            fidl::encoding::DynamicFlags::empty(),
2357            ___deadline,
2358        )?;
2359        Ok(_response.map(|x| x))
2360    }
2361
2362    /// Set `SOL_IP` -> `IP_DROP_MEMBERSHIP`
2363    pub fn r#drop_ip_membership(
2364        &self,
2365        mut membership: &fidl_fuchsia_posix_socket::IpMulticastMembership,
2366        ___deadline: zx::MonotonicInstant,
2367    ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketDropIpMembershipResult, fidl::Error>
2368    {
2369        let _response = self.client.send_query::<
2370            fidl_fuchsia_posix_socket::BaseNetworkSocketDropIpMembershipRequest,
2371            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2372        >(
2373            (membership,),
2374            0x2888f3099188d03,
2375            fidl::encoding::DynamicFlags::empty(),
2376            ___deadline,
2377        )?;
2378        Ok(_response.map(|x| x))
2379    }
2380
2381    /// Set `SOL_IP` -> `IP_TRANSPARENT`
2382    pub fn r#set_ip_transparent(
2383        &self,
2384        mut value: bool,
2385        ___deadline: zx::MonotonicInstant,
2386    ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTransparentResult, fidl::Error>
2387    {
2388        let _response = self.client.send_query::<
2389            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTransparentRequest,
2390            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2391        >(
2392            (value,),
2393            0x1ae532b0c066e3a0,
2394            fidl::encoding::DynamicFlags::empty(),
2395            ___deadline,
2396        )?;
2397        Ok(_response.map(|x| x))
2398    }
2399
2400    /// Get `SOL_IP` -> `IP_TRANSPARENT`
2401    pub fn r#get_ip_transparent(
2402        &self,
2403        ___deadline: zx::MonotonicInstant,
2404    ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTransparentResult, fidl::Error>
2405    {
2406        let _response = self
2407            .client
2408            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2409                fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTransparentResponse,
2410                fidl_fuchsia_posix::Errno,
2411            >>(
2412                (), 0x51d43695962ebfb5, fidl::encoding::DynamicFlags::empty(), ___deadline
2413            )?;
2414        Ok(_response.map(|x| x.value))
2415    }
2416
2417    /// Set `SOL_IP` -> `IP_RECVORIGDSTADDR`
2418    pub fn r#set_ip_receive_original_destination_address(
2419        &self,
2420        mut value: bool,
2421        ___deadline: zx::MonotonicInstant,
2422    ) -> Result<
2423        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
2424        fidl::Error,
2425    > {
2426        let _response = self.client.send_query::<
2427            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest,
2428            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2429        >(
2430            (value,),
2431            0x4722b4ce52f7840,
2432            fidl::encoding::DynamicFlags::empty(),
2433            ___deadline,
2434        )?;
2435        Ok(_response.map(|x| x))
2436    }
2437
2438    /// Get `SOL_IP` -> `IP_RECVORIGDSTADDR`
2439    pub fn r#get_ip_receive_original_destination_address(
2440        &self,
2441        ___deadline: zx::MonotonicInstant,
2442    ) -> Result<
2443        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
2444        fidl::Error,
2445    > {
2446        let _response = self.client.send_query::<
2447            fidl::encoding::EmptyPayload,
2448            fidl::encoding::ResultType<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse, fidl_fuchsia_posix::Errno>,
2449        >(
2450            (),
2451            0x2a0e7dc5d6bfdfe9,
2452            fidl::encoding::DynamicFlags::empty(),
2453            ___deadline,
2454        )?;
2455        Ok(_response.map(|x| x.value))
2456    }
2457
2458    /// Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`.
2459    pub fn r#add_ipv6_membership(
2460        &self,
2461        mut membership: &fidl_fuchsia_posix_socket::Ipv6MulticastMembership,
2462        ___deadline: zx::MonotonicInstant,
2463    ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketAddIpv6MembershipResult, fidl::Error>
2464    {
2465        let _response = self.client.send_query::<
2466            fidl_fuchsia_posix_socket::BaseNetworkSocketAddIpv6MembershipRequest,
2467            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2468        >(
2469            (membership,),
2470            0x7c94727acb4ea4b3,
2471            fidl::encoding::DynamicFlags::empty(),
2472            ___deadline,
2473        )?;
2474        Ok(_response.map(|x| x))
2475    }
2476
2477    /// Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`.
2478    pub fn r#drop_ipv6_membership(
2479        &self,
2480        mut membership: &fidl_fuchsia_posix_socket::Ipv6MulticastMembership,
2481        ___deadline: zx::MonotonicInstant,
2482    ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketDropIpv6MembershipResult, fidl::Error>
2483    {
2484        let _response = self.client.send_query::<
2485            fidl_fuchsia_posix_socket::BaseNetworkSocketDropIpv6MembershipRequest,
2486            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2487        >(
2488            (membership,),
2489            0x42104c70ccaba304,
2490            fidl::encoding::DynamicFlags::empty(),
2491            ___deadline,
2492        )?;
2493        Ok(_response.map(|x| x))
2494    }
2495
2496    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
2497    pub fn r#set_ipv6_multicast_interface(
2498        &self,
2499        mut value: u64,
2500        ___deadline: zx::MonotonicInstant,
2501    ) -> Result<
2502        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastInterfaceResult,
2503        fidl::Error,
2504    > {
2505        let _response = self.client.send_query::<
2506            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastInterfaceRequest,
2507            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2508        >(
2509            (value,),
2510            0x135f76db3774ab3b,
2511            fidl::encoding::DynamicFlags::empty(),
2512            ___deadline,
2513        )?;
2514        Ok(_response.map(|x| x))
2515    }
2516
2517    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
2518    pub fn r#get_ipv6_multicast_interface(
2519        &self,
2520        ___deadline: zx::MonotonicInstant,
2521    ) -> Result<
2522        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastInterfaceResult,
2523        fidl::Error,
2524    > {
2525        let _response = self
2526            .client
2527            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2528                fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
2529                fidl_fuchsia_posix::Errno,
2530            >>(
2531                (), 0x1f26fcdd348f1882, fidl::encoding::DynamicFlags::empty(), ___deadline
2532            )?;
2533        Ok(_response.map(|x| x.value))
2534    }
2535
2536    /// Set `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
2537    pub fn r#set_ipv6_unicast_hops(
2538        &self,
2539        mut value: &fidl_fuchsia_posix_socket::OptionalUint8,
2540        ___deadline: zx::MonotonicInstant,
2541    ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error>
2542    {
2543        let _response = self.client.send_query::<
2544            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6UnicastHopsRequest,
2545            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2546        >(
2547            (value,),
2548            0x157d51e98f462859,
2549            fidl::encoding::DynamicFlags::empty(),
2550            ___deadline,
2551        )?;
2552        Ok(_response.map(|x| x))
2553    }
2554
2555    /// Get `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
2556    pub fn r#get_ipv6_unicast_hops(
2557        &self,
2558        ___deadline: zx::MonotonicInstant,
2559    ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error>
2560    {
2561        let _response = self
2562            .client
2563            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2564                fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6UnicastHopsResponse,
2565                fidl_fuchsia_posix::Errno,
2566            >>(
2567                (), 0x21f4641cad8bd8d2, fidl::encoding::DynamicFlags::empty(), ___deadline
2568            )?;
2569        Ok(_response.map(|x| x.value))
2570    }
2571
2572    /// Set `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
2573    pub fn r#set_ipv6_receive_hop_limit(
2574        &self,
2575        mut value: bool,
2576        ___deadline: zx::MonotonicInstant,
2577    ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error>
2578    {
2579        let _response = self.client.send_query::<
2580            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceiveHopLimitRequest,
2581            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2582        >(
2583            (value,),
2584            0x5c24808ed2e84a1e,
2585            fidl::encoding::DynamicFlags::empty(),
2586            ___deadline,
2587        )?;
2588        Ok(_response.map(|x| x))
2589    }
2590
2591    /// Get `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
2592    pub fn r#get_ipv6_receive_hop_limit(
2593        &self,
2594        ___deadline: zx::MonotonicInstant,
2595    ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error>
2596    {
2597        let _response = self
2598            .client
2599            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2600                fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
2601                fidl_fuchsia_posix::Errno,
2602            >>(
2603                (), 0x341e06689885b4c0, fidl::encoding::DynamicFlags::empty(), ___deadline
2604            )?;
2605        Ok(_response.map(|x| x.value))
2606    }
2607
2608    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
2609    pub fn r#set_ipv6_multicast_hops(
2610        &self,
2611        mut value: &fidl_fuchsia_posix_socket::OptionalUint8,
2612        ___deadline: zx::MonotonicInstant,
2613    ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error>
2614    {
2615        let _response = self.client.send_query::<
2616            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastHopsRequest,
2617            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2618        >(
2619            (value,),
2620            0x25b9cd4d181f82c1,
2621            fidl::encoding::DynamicFlags::empty(),
2622            ___deadline,
2623        )?;
2624        Ok(_response.map(|x| x))
2625    }
2626
2627    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
2628    pub fn r#get_ipv6_multicast_hops(
2629        &self,
2630        ___deadline: zx::MonotonicInstant,
2631    ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error>
2632    {
2633        let _response = self
2634            .client
2635            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2636                fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastHopsResponse,
2637                fidl_fuchsia_posix::Errno,
2638            >>(
2639                (), 0x52916948a365012a, fidl::encoding::DynamicFlags::empty(), ___deadline
2640            )?;
2641        Ok(_response.map(|x| x.value))
2642    }
2643
2644    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
2645    pub fn r#set_ipv6_multicast_loopback(
2646        &self,
2647        mut value: bool,
2648        ___deadline: zx::MonotonicInstant,
2649    ) -> Result<
2650        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastLoopbackResult,
2651        fidl::Error,
2652    > {
2653        let _response = self.client.send_query::<
2654            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastLoopbackRequest,
2655            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2656        >(
2657            (value,),
2658            0x55701c409ff41b40,
2659            fidl::encoding::DynamicFlags::empty(),
2660            ___deadline,
2661        )?;
2662        Ok(_response.map(|x| x))
2663    }
2664
2665    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
2666    pub fn r#get_ipv6_multicast_loopback(
2667        &self,
2668        ___deadline: zx::MonotonicInstant,
2669    ) -> Result<
2670        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastLoopbackResult,
2671        fidl::Error,
2672    > {
2673        let _response = self
2674            .client
2675            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2676                fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
2677                fidl_fuchsia_posix::Errno,
2678            >>(
2679                (), 0x4415b701fde319c3, fidl::encoding::DynamicFlags::empty(), ___deadline
2680            )?;
2681        Ok(_response.map(|x| x.value))
2682    }
2683
2684    /// Set `SOL_IPV6` -> `IPV6_V6ONLY`.
2685    pub fn r#set_ipv6_only(
2686        &self,
2687        mut value: bool,
2688        ___deadline: zx::MonotonicInstant,
2689    ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6OnlyResult, fidl::Error> {
2690        let _response = self.client.send_query::<
2691            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6OnlyRequest,
2692            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2693        >(
2694            (value,),
2695            0x4873f1364758cbba,
2696            fidl::encoding::DynamicFlags::empty(),
2697            ___deadline,
2698        )?;
2699        Ok(_response.map(|x| x))
2700    }
2701
2702    /// Get `SOL_IPV6` -> `IPV6_V6ONLY`.
2703    pub fn r#get_ipv6_only(
2704        &self,
2705        ___deadline: zx::MonotonicInstant,
2706    ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6OnlyResult, fidl::Error> {
2707        let _response = self
2708            .client
2709            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2710                fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6OnlyResponse,
2711                fidl_fuchsia_posix::Errno,
2712            >>(
2713                (), 0x4aa3340a1a26b89c, fidl::encoding::DynamicFlags::empty(), ___deadline
2714            )?;
2715        Ok(_response.map(|x| x.value))
2716    }
2717
2718    /// Set `SOL_IPV6` -> `IPV6_RECVTCLASS`.
2719    pub fn r#set_ipv6_receive_traffic_class(
2720        &self,
2721        mut value: bool,
2722        ___deadline: zx::MonotonicInstant,
2723    ) -> Result<
2724        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
2725        fidl::Error,
2726    > {
2727        let _response = self.client.send_query::<
2728            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest,
2729            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2730        >(
2731            (value,),
2732            0x58f07c8788d099a0,
2733            fidl::encoding::DynamicFlags::empty(),
2734            ___deadline,
2735        )?;
2736        Ok(_response.map(|x| x))
2737    }
2738
2739    /// Get `SOL_IPV6` -> `IPV6_RECVTCLASS`.
2740    pub fn r#get_ipv6_receive_traffic_class(
2741        &self,
2742        ___deadline: zx::MonotonicInstant,
2743    ) -> Result<
2744        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
2745        fidl::Error,
2746    > {
2747        let _response = self
2748            .client
2749            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2750                fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
2751                fidl_fuchsia_posix::Errno,
2752            >>(
2753                (), 0x2e334df1da553ffa, fidl::encoding::DynamicFlags::empty(), ___deadline
2754            )?;
2755        Ok(_response.map(|x| x.value))
2756    }
2757
2758    /// Set `SOL_IPV6` -> `IPV6_TCLASS`
2759    pub fn r#set_ipv6_traffic_class(
2760        &self,
2761        mut value: &fidl_fuchsia_posix_socket::OptionalUint8,
2762        ___deadline: zx::MonotonicInstant,
2763    ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error>
2764    {
2765        let _response = self.client.send_query::<
2766            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6TrafficClassRequest,
2767            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2768        >(
2769            (value,),
2770            0x6af077800c5a0b4f,
2771            fidl::encoding::DynamicFlags::empty(),
2772            ___deadline,
2773        )?;
2774        Ok(_response.map(|x| x))
2775    }
2776
2777    /// Get `SOL_IPV6` -> `IPV6_TCLASS`.
2778    pub fn r#get_ipv6_traffic_class(
2779        &self,
2780        ___deadline: zx::MonotonicInstant,
2781    ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error>
2782    {
2783        let _response = self
2784            .client
2785            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2786                fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6TrafficClassResponse,
2787                fidl_fuchsia_posix::Errno,
2788            >>(
2789                (), 0x6baf6eed8fc2f04, fidl::encoding::DynamicFlags::empty(), ___deadline
2790            )?;
2791        Ok(_response.map(|x| x.value))
2792    }
2793
2794    /// Set `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
2795    pub fn r#set_ipv6_receive_packet_info(
2796        &self,
2797        mut value: bool,
2798        ___deadline: zx::MonotonicInstant,
2799    ) -> Result<
2800        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
2801        fidl::Error,
2802    > {
2803        let _response = self.client.send_query::<
2804            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceivePacketInfoRequest,
2805            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
2806        >(
2807            (value,),
2808            0x19259775b1a92768,
2809            fidl::encoding::DynamicFlags::empty(),
2810            ___deadline,
2811        )?;
2812        Ok(_response.map(|x| x))
2813    }
2814
2815    /// Get `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
2816    pub fn r#get_ipv6_receive_packet_info(
2817        &self,
2818        ___deadline: zx::MonotonicInstant,
2819    ) -> Result<
2820        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
2821        fidl::Error,
2822    > {
2823        let _response = self
2824            .client
2825            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2826                fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
2827                fidl_fuchsia_posix::Errno,
2828            >>(
2829                (), 0x7acd4a2775baec75, fidl::encoding::DynamicFlags::empty(), ___deadline
2830            )?;
2831        Ok(_response.map(|x| x.value))
2832    }
2833
2834    /// Get `SOL_IP` -> `SO_ORIGINAL_DST`.
2835    pub fn r#get_original_destination(
2836        &self,
2837        ___deadline: zx::MonotonicInstant,
2838    ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetOriginalDestinationResult, fidl::Error>
2839    {
2840        let _response = self
2841            .client
2842            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2843                fidl_fuchsia_posix_socket::BaseNetworkSocketGetOriginalDestinationResponse,
2844                fidl_fuchsia_posix::Errno,
2845            >>(
2846                (), 0x38bf28f0dafdbac0, fidl::encoding::DynamicFlags::empty(), ___deadline
2847            )?;
2848        Ok(_response.map(|x| x.value))
2849    }
2850
2851    pub fn r#describe(
2852        &self,
2853        ___deadline: zx::MonotonicInstant,
2854    ) -> Result<SocketDescribeResponse, fidl::Error> {
2855        let _response =
2856            self.client.send_query::<fidl::encoding::EmptyPayload, SocketDescribeResponse>(
2857                (),
2858                0x335706eccf54a135,
2859                fidl::encoding::DynamicFlags::empty(),
2860                ___deadline,
2861            )?;
2862        Ok(_response)
2863    }
2864
2865    /// Receives a message from the socket.
2866    ///
2867    /// + request `want_addr` request message's source address information to
2868    ///   be returned.
2869    /// + request `data_len` the maximum allowed length of the response data
2870    ///   buffer.
2871    /// + request `want_control` request ancillary data to be returned.
2872    /// + request `flags` flags for the receive request.
2873    /// - response `addr` the message's source address information, if
2874    ///   requested.
2875    /// - response `data` the message.
2876    /// - response `control` control messages, if requested.
2877    /// - response `truncated` indicates whether or not the returned message
2878    ///   was truncated.
2879    pub fn r#recv_msg(
2880        &self,
2881        mut want_addr: bool,
2882        mut data_len: u32,
2883        mut want_control: bool,
2884        mut flags: fidl_fuchsia_posix_socket::RecvMsgFlags,
2885        ___deadline: zx::MonotonicInstant,
2886    ) -> Result<SocketRecvMsgResult, fidl::Error> {
2887        let _response = self.client.send_query::<SocketRecvMsgRequest, fidl::encoding::ResultType<
2888            SocketRecvMsgResponse,
2889            fidl_fuchsia_posix::Errno,
2890        >>(
2891            (want_addr, data_len, want_control, flags),
2892            0x1dfb695351d3aa1d,
2893            fidl::encoding::DynamicFlags::empty(),
2894            ___deadline,
2895        )?;
2896        Ok(_response.map(|x| (x.addr, x.data, x.control, x.truncated)))
2897    }
2898
2899    /// Sends a message on the socket.
2900    ///
2901    /// + request `addr` the address to send the message to. If unset, will
2902    ///   send to the connected peer.
2903    /// + request `data` the message.
2904    /// + request `control` ancillary data.
2905    /// + request `flags` flags for the send request.
2906    pub fn r#send_msg(
2907        &self,
2908        mut addr: Option<&fidl_fuchsia_net::SocketAddress>,
2909        mut data: &[u8],
2910        mut control: &fidl_fuchsia_posix_socket::NetworkSocketSendControlData,
2911        mut flags: fidl_fuchsia_posix_socket::SendMsgFlags,
2912        ___deadline: zx::MonotonicInstant,
2913    ) -> Result<SocketSendMsgResult, fidl::Error> {
2914        let _response = self.client.send_query::<SocketSendMsgRequest, fidl::encoding::ResultType<
2915            fidl::encoding::EmptyStruct,
2916            fidl_fuchsia_posix::Errno,
2917        >>(
2918            (addr, data, control, flags),
2919            0x2cf1eac9a7fc8958,
2920            fidl::encoding::DynamicFlags::empty(),
2921            ___deadline,
2922        )?;
2923        Ok(_response.map(|x| x))
2924    }
2925
2926    /// Retrieves creation information from the socket.
2927    ///
2928    /// - response `domain` the socket's associated domain.
2929    /// - response `proto` the socket's associated protocol.
2930    pub fn r#get_info(
2931        &self,
2932        ___deadline: zx::MonotonicInstant,
2933    ) -> Result<SocketGetInfoResult, fidl::Error> {
2934        let _response =
2935            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2936                SocketGetInfoResponse,
2937                fidl_fuchsia_posix::Errno,
2938            >>(
2939                (),
2940                0x39676f75aec339ba,
2941                fidl::encoding::DynamicFlags::empty(),
2942                ___deadline,
2943            )?;
2944        Ok(_response.map(|x| (x.domain, x.proto)))
2945    }
2946
2947    /// Set `SOL_IP` -> `IP_HDRINCL`.
2948    pub fn r#set_ip_header_included(
2949        &self,
2950        mut value: bool,
2951        ___deadline: zx::MonotonicInstant,
2952    ) -> Result<SocketSetIpHeaderIncludedResult, fidl::Error> {
2953        let _response =
2954            self.client.send_query::<SocketSetIpHeaderIncludedRequest, fidl::encoding::ResultType<
2955                fidl::encoding::EmptyStruct,
2956                fidl_fuchsia_posix::Errno,
2957            >>(
2958                (value,),
2959                0x5d06a606d95e8f3,
2960                fidl::encoding::DynamicFlags::empty(),
2961                ___deadline,
2962            )?;
2963        Ok(_response.map(|x| x))
2964    }
2965
2966    /// Get `SOL_IP` -> `IP_HDRINCL`.
2967    pub fn r#get_ip_header_included(
2968        &self,
2969        ___deadline: zx::MonotonicInstant,
2970    ) -> Result<SocketGetIpHeaderIncludedResult, fidl::Error> {
2971        let _response = self
2972            .client
2973            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2974                SocketGetIpHeaderIncludedResponse,
2975                fidl_fuchsia_posix::Errno,
2976            >>(
2977                (), 0x76125ad1f4d175f6, fidl::encoding::DynamicFlags::empty(), ___deadline
2978            )?;
2979        Ok(_response.map(|x| x.value))
2980    }
2981
2982    /// Set `SOL_ICMPV6` -> `ICMP6_FILTER`.
2983    pub fn r#set_icmpv6_filter(
2984        &self,
2985        mut filter: &Icmpv6Filter,
2986        ___deadline: zx::MonotonicInstant,
2987    ) -> Result<SocketSetIcmpv6FilterResult, fidl::Error> {
2988        let _response =
2989            self.client.send_query::<SocketSetIcmpv6FilterRequest, fidl::encoding::ResultType<
2990                fidl::encoding::EmptyStruct,
2991                fidl_fuchsia_posix::Errno,
2992            >>(
2993                (filter,),
2994                0x4ebea92a43ae68a9,
2995                fidl::encoding::DynamicFlags::empty(),
2996                ___deadline,
2997            )?;
2998        Ok(_response.map(|x| x))
2999    }
3000
3001    /// Get `SOL_ICMPV6` -> `ICMP6_FILTER`.
3002    pub fn r#get_icmpv6_filter(
3003        &self,
3004        ___deadline: zx::MonotonicInstant,
3005    ) -> Result<SocketGetIcmpv6FilterResult, fidl::Error> {
3006        let _response =
3007            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
3008                SocketGetIcmpv6FilterResponse,
3009                fidl_fuchsia_posix::Errno,
3010            >>(
3011                (),
3012                0x43bd4f3bc0970ace,
3013                fidl::encoding::DynamicFlags::empty(),
3014                ___deadline,
3015            )?;
3016        Ok(_response.map(|x| x.filter))
3017    }
3018
3019    /// Set `SOL_IPV6` -> `IPV6_CHECKSUM`.
3020    pub fn r#set_ipv6_checksum(
3021        &self,
3022        mut config: &Ipv6ChecksumConfiguration,
3023        ___deadline: zx::MonotonicInstant,
3024    ) -> Result<SocketSetIpv6ChecksumResult, fidl::Error> {
3025        let _response =
3026            self.client.send_query::<SocketSetIpv6ChecksumRequest, fidl::encoding::ResultType<
3027                fidl::encoding::EmptyStruct,
3028                fidl_fuchsia_posix::Errno,
3029            >>(
3030                (config,),
3031                0x18b7809577199cb4,
3032                fidl::encoding::DynamicFlags::empty(),
3033                ___deadline,
3034            )?;
3035        Ok(_response.map(|x| x))
3036    }
3037
3038    /// Get `SOL_IPV6` -> `IPV6_CHECKSUM`.
3039    pub fn r#get_ipv6_checksum(
3040        &self,
3041        ___deadline: zx::MonotonicInstant,
3042    ) -> Result<SocketGetIpv6ChecksumResult, fidl::Error> {
3043        let _response =
3044            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
3045                SocketGetIpv6ChecksumResponse,
3046                fidl_fuchsia_posix::Errno,
3047            >>(
3048                (),
3049                0x1847bf5b2d263dd,
3050                fidl::encoding::DynamicFlags::empty(),
3051                ___deadline,
3052            )?;
3053        Ok(_response.map(|x| x.config))
3054    }
3055}
3056
3057#[cfg(target_os = "fuchsia")]
3058impl From<SocketSynchronousProxy> for zx::Handle {
3059    fn from(value: SocketSynchronousProxy) -> Self {
3060        value.into_channel().into()
3061    }
3062}
3063
3064#[cfg(target_os = "fuchsia")]
3065impl From<fidl::Channel> for SocketSynchronousProxy {
3066    fn from(value: fidl::Channel) -> Self {
3067        Self::new(value)
3068    }
3069}
3070
3071#[cfg(target_os = "fuchsia")]
3072impl fidl::endpoints::FromClient for SocketSynchronousProxy {
3073    type Protocol = SocketMarker;
3074
3075    fn from_client(value: fidl::endpoints::ClientEnd<SocketMarker>) -> Self {
3076        Self::new(value.into_channel())
3077    }
3078}
3079
3080#[derive(Debug, Clone)]
3081pub struct SocketProxy {
3082    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
3083}
3084
3085impl fidl::endpoints::Proxy for SocketProxy {
3086    type Protocol = SocketMarker;
3087
3088    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
3089        Self::new(inner)
3090    }
3091
3092    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
3093        self.client.into_channel().map_err(|client| Self { client })
3094    }
3095
3096    fn as_channel(&self) -> &::fidl::AsyncChannel {
3097        self.client.as_channel()
3098    }
3099}
3100
3101impl SocketProxy {
3102    /// Create a new Proxy for fuchsia.posix.socket.raw/Socket.
3103    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
3104        let protocol_name = <SocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
3105        Self { client: fidl::client::Client::new(channel, protocol_name) }
3106    }
3107
3108    /// Get a Stream of events from the remote end of the protocol.
3109    ///
3110    /// # Panics
3111    ///
3112    /// Panics if the event stream was already taken.
3113    pub fn take_event_stream(&self) -> SocketEventStream {
3114        SocketEventStream { event_receiver: self.client.take_event_receiver() }
3115    }
3116
3117    pub fn r#clone(
3118        &self,
3119        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
3120    ) -> Result<(), fidl::Error> {
3121        SocketProxyInterface::r#clone(self, request)
3122    }
3123
3124    /// Terminates the connection.
3125    ///
3126    /// After calling `Close`, the client must not send any other requests.
3127    ///
3128    /// Servers, after sending the status response, should close the connection
3129    /// regardless of status and without sending an epitaph.
3130    ///
3131    /// Closing the client end of the channel should be semantically equivalent
3132    /// to calling `Close` without knowing when the close has completed or its
3133    /// status.
3134    pub fn r#close(
3135        &self,
3136    ) -> fidl::client::QueryResponseFut<
3137        fidl_fuchsia_unknown::CloseableCloseResult,
3138        fidl::encoding::DefaultFuchsiaResourceDialect,
3139    > {
3140        SocketProxyInterface::r#close(self)
3141    }
3142
3143    pub fn r#query(
3144        &self,
3145    ) -> fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>
3146    {
3147        SocketProxyInterface::r#query(self)
3148    }
3149
3150    /// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
3151    pub fn r#set_reuse_address(
3152        &self,
3153        mut value: bool,
3154    ) -> fidl::client::QueryResponseFut<
3155        fidl_fuchsia_posix_socket::BaseSocketSetReuseAddressResult,
3156        fidl::encoding::DefaultFuchsiaResourceDialect,
3157    > {
3158        SocketProxyInterface::r#set_reuse_address(self, value)
3159    }
3160
3161    /// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
3162    pub fn r#get_reuse_address(
3163        &self,
3164    ) -> fidl::client::QueryResponseFut<
3165        fidl_fuchsia_posix_socket::BaseSocketGetReuseAddressResult,
3166        fidl::encoding::DefaultFuchsiaResourceDialect,
3167    > {
3168        SocketProxyInterface::r#get_reuse_address(self)
3169    }
3170
3171    /// Get `SOL_SOCKET` -> `SO_ERROR`.
3172    /// Returns the last error if there is an error set on the socket.
3173    pub fn r#get_error(
3174        &self,
3175    ) -> fidl::client::QueryResponseFut<
3176        fidl_fuchsia_posix_socket::BaseSocketGetErrorResult,
3177        fidl::encoding::DefaultFuchsiaResourceDialect,
3178    > {
3179        SocketProxyInterface::r#get_error(self)
3180    }
3181
3182    /// Set `SOL_SOCKET` -> `SO_BROADCAST`.
3183    pub fn r#set_broadcast(
3184        &self,
3185        mut value: bool,
3186    ) -> fidl::client::QueryResponseFut<
3187        fidl_fuchsia_posix_socket::BaseSocketSetBroadcastResult,
3188        fidl::encoding::DefaultFuchsiaResourceDialect,
3189    > {
3190        SocketProxyInterface::r#set_broadcast(self, value)
3191    }
3192
3193    /// Get `SOL_SOCKET` -> `SO_BROADCAST`.
3194    pub fn r#get_broadcast(
3195        &self,
3196    ) -> fidl::client::QueryResponseFut<
3197        fidl_fuchsia_posix_socket::BaseSocketGetBroadcastResult,
3198        fidl::encoding::DefaultFuchsiaResourceDialect,
3199    > {
3200        SocketProxyInterface::r#get_broadcast(self)
3201    }
3202
3203    /// Set `SOL_SOCKET` -> `SO_SNDBUF`.
3204    pub fn r#set_send_buffer(
3205        &self,
3206        mut value_bytes: u64,
3207    ) -> fidl::client::QueryResponseFut<
3208        fidl_fuchsia_posix_socket::BaseSocketSetSendBufferResult,
3209        fidl::encoding::DefaultFuchsiaResourceDialect,
3210    > {
3211        SocketProxyInterface::r#set_send_buffer(self, value_bytes)
3212    }
3213
3214    /// Get `SOL_SOCKET` -> `SO_SNDBUF`.
3215    pub fn r#get_send_buffer(
3216        &self,
3217    ) -> fidl::client::QueryResponseFut<
3218        fidl_fuchsia_posix_socket::BaseSocketGetSendBufferResult,
3219        fidl::encoding::DefaultFuchsiaResourceDialect,
3220    > {
3221        SocketProxyInterface::r#get_send_buffer(self)
3222    }
3223
3224    /// Set `SOL_SOCKET` -> `SO_RCVBUF`.
3225    pub fn r#set_receive_buffer(
3226        &self,
3227        mut value_bytes: u64,
3228    ) -> fidl::client::QueryResponseFut<
3229        fidl_fuchsia_posix_socket::BaseSocketSetReceiveBufferResult,
3230        fidl::encoding::DefaultFuchsiaResourceDialect,
3231    > {
3232        SocketProxyInterface::r#set_receive_buffer(self, value_bytes)
3233    }
3234
3235    /// Get `SOL_SOCKET` -> `SO_RCVBUF`.
3236    pub fn r#get_receive_buffer(
3237        &self,
3238    ) -> fidl::client::QueryResponseFut<
3239        fidl_fuchsia_posix_socket::BaseSocketGetReceiveBufferResult,
3240        fidl::encoding::DefaultFuchsiaResourceDialect,
3241    > {
3242        SocketProxyInterface::r#get_receive_buffer(self)
3243    }
3244
3245    /// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
3246    pub fn r#set_keep_alive(
3247        &self,
3248        mut value: bool,
3249    ) -> fidl::client::QueryResponseFut<
3250        fidl_fuchsia_posix_socket::BaseSocketSetKeepAliveResult,
3251        fidl::encoding::DefaultFuchsiaResourceDialect,
3252    > {
3253        SocketProxyInterface::r#set_keep_alive(self, value)
3254    }
3255
3256    /// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
3257    pub fn r#get_keep_alive(
3258        &self,
3259    ) -> fidl::client::QueryResponseFut<
3260        fidl_fuchsia_posix_socket::BaseSocketGetKeepAliveResult,
3261        fidl::encoding::DefaultFuchsiaResourceDialect,
3262    > {
3263        SocketProxyInterface::r#get_keep_alive(self)
3264    }
3265
3266    /// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
3267    pub fn r#set_out_of_band_inline(
3268        &self,
3269        mut value: bool,
3270    ) -> fidl::client::QueryResponseFut<
3271        fidl_fuchsia_posix_socket::BaseSocketSetOutOfBandInlineResult,
3272        fidl::encoding::DefaultFuchsiaResourceDialect,
3273    > {
3274        SocketProxyInterface::r#set_out_of_band_inline(self, value)
3275    }
3276
3277    /// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
3278    pub fn r#get_out_of_band_inline(
3279        &self,
3280    ) -> fidl::client::QueryResponseFut<
3281        fidl_fuchsia_posix_socket::BaseSocketGetOutOfBandInlineResult,
3282        fidl::encoding::DefaultFuchsiaResourceDialect,
3283    > {
3284        SocketProxyInterface::r#get_out_of_band_inline(self)
3285    }
3286
3287    /// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
3288    pub fn r#set_no_check(
3289        &self,
3290        mut value: bool,
3291    ) -> fidl::client::QueryResponseFut<
3292        fidl_fuchsia_posix_socket::BaseSocketSetNoCheckResult,
3293        fidl::encoding::DefaultFuchsiaResourceDialect,
3294    > {
3295        SocketProxyInterface::r#set_no_check(self, value)
3296    }
3297
3298    /// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
3299    pub fn r#get_no_check(
3300        &self,
3301    ) -> fidl::client::QueryResponseFut<
3302        fidl_fuchsia_posix_socket::BaseSocketGetNoCheckResult,
3303        fidl::encoding::DefaultFuchsiaResourceDialect,
3304    > {
3305        SocketProxyInterface::r#get_no_check(self)
3306    }
3307
3308    /// Set `SOL_SOCKET` -> `SO_LINGER`.
3309    pub fn r#set_linger(
3310        &self,
3311        mut linger: bool,
3312        mut length_secs: u32,
3313    ) -> fidl::client::QueryResponseFut<
3314        fidl_fuchsia_posix_socket::BaseSocketSetLingerResult,
3315        fidl::encoding::DefaultFuchsiaResourceDialect,
3316    > {
3317        SocketProxyInterface::r#set_linger(self, linger, length_secs)
3318    }
3319
3320    /// Get `SOL_SOCKET` -> `SO_LINGER`.
3321    pub fn r#get_linger(
3322        &self,
3323    ) -> fidl::client::QueryResponseFut<
3324        fidl_fuchsia_posix_socket::BaseSocketGetLingerResult,
3325        fidl::encoding::DefaultFuchsiaResourceDialect,
3326    > {
3327        SocketProxyInterface::r#get_linger(self)
3328    }
3329
3330    /// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
3331    pub fn r#set_reuse_port(
3332        &self,
3333        mut value: bool,
3334    ) -> fidl::client::QueryResponseFut<
3335        fidl_fuchsia_posix_socket::BaseSocketSetReusePortResult,
3336        fidl::encoding::DefaultFuchsiaResourceDialect,
3337    > {
3338        SocketProxyInterface::r#set_reuse_port(self, value)
3339    }
3340
3341    /// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
3342    pub fn r#get_reuse_port(
3343        &self,
3344    ) -> fidl::client::QueryResponseFut<
3345        fidl_fuchsia_posix_socket::BaseSocketGetReusePortResult,
3346        fidl::encoding::DefaultFuchsiaResourceDialect,
3347    > {
3348        SocketProxyInterface::r#get_reuse_port(self)
3349    }
3350
3351    /// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
3352    pub fn r#get_accept_conn(
3353        &self,
3354    ) -> fidl::client::QueryResponseFut<
3355        fidl_fuchsia_posix_socket::BaseSocketGetAcceptConnResult,
3356        fidl::encoding::DefaultFuchsiaResourceDialect,
3357    > {
3358        SocketProxyInterface::r#get_accept_conn(self)
3359    }
3360
3361    /// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
3362    pub fn r#set_bind_to_device(
3363        &self,
3364        mut value: &str,
3365    ) -> fidl::client::QueryResponseFut<
3366        fidl_fuchsia_posix_socket::BaseSocketSetBindToDeviceResult,
3367        fidl::encoding::DefaultFuchsiaResourceDialect,
3368    > {
3369        SocketProxyInterface::r#set_bind_to_device(self, value)
3370    }
3371
3372    /// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
3373    pub fn r#get_bind_to_device(
3374        &self,
3375    ) -> fidl::client::QueryResponseFut<
3376        fidl_fuchsia_posix_socket::BaseSocketGetBindToDeviceResult,
3377        fidl::encoding::DefaultFuchsiaResourceDialect,
3378    > {
3379        SocketProxyInterface::r#get_bind_to_device(self)
3380    }
3381
3382    /// Set `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
3383    /// If `value` is 0, this clears the bound interface.
3384    pub fn r#set_bind_to_interface_index(
3385        &self,
3386        mut value: u64,
3387    ) -> fidl::client::QueryResponseFut<
3388        fidl_fuchsia_posix_socket::BaseSocketSetBindToInterfaceIndexResult,
3389        fidl::encoding::DefaultFuchsiaResourceDialect,
3390    > {
3391        SocketProxyInterface::r#set_bind_to_interface_index(self, value)
3392    }
3393
3394    /// Get `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
3395    pub fn r#get_bind_to_interface_index(
3396        &self,
3397    ) -> fidl::client::QueryResponseFut<
3398        fidl_fuchsia_posix_socket::BaseSocketGetBindToInterfaceIndexResult,
3399        fidl::encoding::DefaultFuchsiaResourceDialect,
3400    > {
3401        SocketProxyInterface::r#get_bind_to_interface_index(self)
3402    }
3403
3404    /// Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
3405    pub fn r#set_timestamp(
3406        &self,
3407        mut value: fidl_fuchsia_posix_socket::TimestampOption,
3408    ) -> fidl::client::QueryResponseFut<
3409        fidl_fuchsia_posix_socket::BaseSocketSetTimestampResult,
3410        fidl::encoding::DefaultFuchsiaResourceDialect,
3411    > {
3412        SocketProxyInterface::r#set_timestamp(self, value)
3413    }
3414
3415    /// Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
3416    pub fn r#get_timestamp(
3417        &self,
3418    ) -> fidl::client::QueryResponseFut<
3419        fidl_fuchsia_posix_socket::BaseSocketGetTimestampResult,
3420        fidl::encoding::DefaultFuchsiaResourceDialect,
3421    > {
3422        SocketProxyInterface::r#get_timestamp(self)
3423    }
3424
3425    /// Like setting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
3426    /// unlike the standard SO_MARK, this API has multiple mark domains and each
3427    /// mark can be set independently in each domain.
3428    pub fn r#set_mark(
3429        &self,
3430        mut domain: fidl_fuchsia_net::MarkDomain,
3431        mut mark: &fidl_fuchsia_posix_socket::OptionalUint32,
3432    ) -> fidl::client::QueryResponseFut<
3433        fidl_fuchsia_posix_socket::BaseSocketSetMarkResult,
3434        fidl::encoding::DefaultFuchsiaResourceDialect,
3435    > {
3436        SocketProxyInterface::r#set_mark(self, domain, mark)
3437    }
3438
3439    /// Like getting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
3440    /// unlike the standard SO_MARK, this API has multiple mark domains and each
3441    /// mark can be retrieved independently in each domain.
3442    pub fn r#get_mark(
3443        &self,
3444        mut domain: fidl_fuchsia_net::MarkDomain,
3445    ) -> fidl::client::QueryResponseFut<
3446        fidl_fuchsia_posix_socket::BaseSocketGetMarkResult,
3447        fidl::encoding::DefaultFuchsiaResourceDialect,
3448    > {
3449        SocketProxyInterface::r#get_mark(self, domain)
3450    }
3451
3452    /// Get `SOL_SOCKET` -> `SO_COOKIE`.
3453    pub fn r#get_cookie(
3454        &self,
3455    ) -> fidl::client::QueryResponseFut<
3456        fidl_fuchsia_posix_socket::BaseSocketGetCookieResult,
3457        fidl::encoding::DefaultFuchsiaResourceDialect,
3458    > {
3459        SocketProxyInterface::r#get_cookie(self)
3460    }
3461
3462    /// Sets the local address used for the socket.
3463    pub fn r#bind(
3464        &self,
3465        mut addr: &fidl_fuchsia_net::SocketAddress,
3466    ) -> fidl::client::QueryResponseFut<
3467        fidl_fuchsia_posix_socket::BaseNetworkSocketBindResult,
3468        fidl::encoding::DefaultFuchsiaResourceDialect,
3469    > {
3470        SocketProxyInterface::r#bind(self, addr)
3471    }
3472
3473    /// Initiates a connection to a remote address.
3474    pub fn r#connect(
3475        &self,
3476        mut addr: &fidl_fuchsia_net::SocketAddress,
3477    ) -> fidl::client::QueryResponseFut<
3478        fidl_fuchsia_posix_socket::BaseNetworkSocketConnectResult,
3479        fidl::encoding::DefaultFuchsiaResourceDialect,
3480    > {
3481        SocketProxyInterface::r#connect(self, addr)
3482    }
3483
3484    /// Clears connection information from this socket.
3485    pub fn r#disconnect(
3486        &self,
3487    ) -> fidl::client::QueryResponseFut<
3488        fidl_fuchsia_posix_socket::BaseNetworkSocketDisconnectResult,
3489        fidl::encoding::DefaultFuchsiaResourceDialect,
3490    > {
3491        SocketProxyInterface::r#disconnect(self)
3492    }
3493
3494    /// Retrieves the local socket address.
3495    pub fn r#get_sock_name(
3496        &self,
3497    ) -> fidl::client::QueryResponseFut<
3498        fidl_fuchsia_posix_socket::BaseNetworkSocketGetSockNameResult,
3499        fidl::encoding::DefaultFuchsiaResourceDialect,
3500    > {
3501        SocketProxyInterface::r#get_sock_name(self)
3502    }
3503
3504    /// Retrieves the remote socket address.
3505    pub fn r#get_peer_name(
3506        &self,
3507    ) -> fidl::client::QueryResponseFut<
3508        fidl_fuchsia_posix_socket::BaseNetworkSocketGetPeerNameResult,
3509        fidl::encoding::DefaultFuchsiaResourceDialect,
3510    > {
3511        SocketProxyInterface::r#get_peer_name(self)
3512    }
3513
3514    /// Shuts down part of the socket.
3515    pub fn r#shutdown(
3516        &self,
3517        mut mode: fidl_fuchsia_posix_socket::ShutdownMode,
3518    ) -> fidl::client::QueryResponseFut<
3519        fidl_fuchsia_posix_socket::BaseNetworkSocketShutdownResult,
3520        fidl::encoding::DefaultFuchsiaResourceDialect,
3521    > {
3522        SocketProxyInterface::r#shutdown(self, mode)
3523    }
3524
3525    /// Set `SOL_IP` -> `IP_TOS`.
3526    pub fn r#set_ip_type_of_service(
3527        &self,
3528        mut value: u8,
3529    ) -> fidl::client::QueryResponseFut<
3530        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTypeOfServiceResult,
3531        fidl::encoding::DefaultFuchsiaResourceDialect,
3532    > {
3533        SocketProxyInterface::r#set_ip_type_of_service(self, value)
3534    }
3535
3536    /// Get `SOL_IP` -> `IP_TOS`.
3537    pub fn r#get_ip_type_of_service(
3538        &self,
3539    ) -> fidl::client::QueryResponseFut<
3540        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTypeOfServiceResult,
3541        fidl::encoding::DefaultFuchsiaResourceDialect,
3542    > {
3543        SocketProxyInterface::r#get_ip_type_of_service(self)
3544    }
3545
3546    /// Set `SOL_IP` -> `IP_TTL`.
3547    pub fn r#set_ip_ttl(
3548        &self,
3549        mut value: &fidl_fuchsia_posix_socket::OptionalUint8,
3550    ) -> fidl::client::QueryResponseFut<
3551        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTtlResult,
3552        fidl::encoding::DefaultFuchsiaResourceDialect,
3553    > {
3554        SocketProxyInterface::r#set_ip_ttl(self, value)
3555    }
3556
3557    /// Get `SOL_IP` -> `IP_TTL`.
3558    pub fn r#get_ip_ttl(
3559        &self,
3560    ) -> fidl::client::QueryResponseFut<
3561        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTtlResult,
3562        fidl::encoding::DefaultFuchsiaResourceDialect,
3563    > {
3564        SocketProxyInterface::r#get_ip_ttl(self)
3565    }
3566
3567    /// Set `SOL_IP` -> `IP_PKTINFO`.
3568    pub fn r#set_ip_packet_info(
3569        &self,
3570        mut value: bool,
3571    ) -> fidl::client::QueryResponseFut<
3572        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpPacketInfoResult,
3573        fidl::encoding::DefaultFuchsiaResourceDialect,
3574    > {
3575        SocketProxyInterface::r#set_ip_packet_info(self, value)
3576    }
3577
3578    /// Get `SOL_IP` -> `IP_PKTINFO`.
3579    pub fn r#get_ip_packet_info(
3580        &self,
3581    ) -> fidl::client::QueryResponseFut<
3582        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpPacketInfoResult,
3583        fidl::encoding::DefaultFuchsiaResourceDialect,
3584    > {
3585        SocketProxyInterface::r#get_ip_packet_info(self)
3586    }
3587
3588    /// Set `SOL_IP` -> `IP_RECVTOS`.
3589    pub fn r#set_ip_receive_type_of_service(
3590        &self,
3591        mut value: bool,
3592    ) -> fidl::client::QueryResponseFut<
3593        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
3594        fidl::encoding::DefaultFuchsiaResourceDialect,
3595    > {
3596        SocketProxyInterface::r#set_ip_receive_type_of_service(self, value)
3597    }
3598
3599    /// Get `SOL_IP` -> `IP_RECVTOS`.
3600    pub fn r#get_ip_receive_type_of_service(
3601        &self,
3602    ) -> fidl::client::QueryResponseFut<
3603        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
3604        fidl::encoding::DefaultFuchsiaResourceDialect,
3605    > {
3606        SocketProxyInterface::r#get_ip_receive_type_of_service(self)
3607    }
3608
3609    /// Set `SOL_IP` -> `IP_RECVTTL`.
3610    pub fn r#set_ip_receive_ttl(
3611        &self,
3612        mut value: bool,
3613    ) -> fidl::client::QueryResponseFut<
3614        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveTtlResult,
3615        fidl::encoding::DefaultFuchsiaResourceDialect,
3616    > {
3617        SocketProxyInterface::r#set_ip_receive_ttl(self, value)
3618    }
3619
3620    /// Get `SOL_IP` -> `IP_RECVTTL`.
3621    pub fn r#get_ip_receive_ttl(
3622        &self,
3623    ) -> fidl::client::QueryResponseFut<
3624        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveTtlResult,
3625        fidl::encoding::DefaultFuchsiaResourceDialect,
3626    > {
3627        SocketProxyInterface::r#get_ip_receive_ttl(self)
3628    }
3629
3630    /// Set `SOL_IP` -> `IP_MULTICAST_IF`.
3631    pub fn r#set_ip_multicast_interface(
3632        &self,
3633        mut iface: u64,
3634        mut address: &fidl_fuchsia_net::Ipv4Address,
3635    ) -> fidl::client::QueryResponseFut<
3636        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastInterfaceResult,
3637        fidl::encoding::DefaultFuchsiaResourceDialect,
3638    > {
3639        SocketProxyInterface::r#set_ip_multicast_interface(self, iface, address)
3640    }
3641
3642    /// Get `SOL_IP` -> `IP_MULTICAST_IF`.
3643    pub fn r#get_ip_multicast_interface(
3644        &self,
3645    ) -> fidl::client::QueryResponseFut<
3646        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastInterfaceResult,
3647        fidl::encoding::DefaultFuchsiaResourceDialect,
3648    > {
3649        SocketProxyInterface::r#get_ip_multicast_interface(self)
3650    }
3651
3652    /// Set `SOL_IP` -> `IP_MULTICAST_TTL`.
3653    pub fn r#set_ip_multicast_ttl(
3654        &self,
3655        mut value: &fidl_fuchsia_posix_socket::OptionalUint8,
3656    ) -> fidl::client::QueryResponseFut<
3657        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastTtlResult,
3658        fidl::encoding::DefaultFuchsiaResourceDialect,
3659    > {
3660        SocketProxyInterface::r#set_ip_multicast_ttl(self, value)
3661    }
3662
3663    /// Get `SOL_IP` -> `IP_MULTICAST_TTL`.
3664    pub fn r#get_ip_multicast_ttl(
3665        &self,
3666    ) -> fidl::client::QueryResponseFut<
3667        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastTtlResult,
3668        fidl::encoding::DefaultFuchsiaResourceDialect,
3669    > {
3670        SocketProxyInterface::r#get_ip_multicast_ttl(self)
3671    }
3672
3673    /// Set `SOL_IP` -> `IP_MULTICAST_LOOP`.
3674    pub fn r#set_ip_multicast_loopback(
3675        &self,
3676        mut value: bool,
3677    ) -> fidl::client::QueryResponseFut<
3678        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastLoopbackResult,
3679        fidl::encoding::DefaultFuchsiaResourceDialect,
3680    > {
3681        SocketProxyInterface::r#set_ip_multicast_loopback(self, value)
3682    }
3683
3684    /// Get `SOL_IP` -> `IP_MULTICAST_LOOP`.
3685    pub fn r#get_ip_multicast_loopback(
3686        &self,
3687    ) -> fidl::client::QueryResponseFut<
3688        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastLoopbackResult,
3689        fidl::encoding::DefaultFuchsiaResourceDialect,
3690    > {
3691        SocketProxyInterface::r#get_ip_multicast_loopback(self)
3692    }
3693
3694    /// Set `SOL_IP` -> `IP_ADD_MEMBERSHIP`
3695    pub fn r#add_ip_membership(
3696        &self,
3697        mut membership: &fidl_fuchsia_posix_socket::IpMulticastMembership,
3698    ) -> fidl::client::QueryResponseFut<
3699        fidl_fuchsia_posix_socket::BaseNetworkSocketAddIpMembershipResult,
3700        fidl::encoding::DefaultFuchsiaResourceDialect,
3701    > {
3702        SocketProxyInterface::r#add_ip_membership(self, membership)
3703    }
3704
3705    /// Set `SOL_IP` -> `IP_DROP_MEMBERSHIP`
3706    pub fn r#drop_ip_membership(
3707        &self,
3708        mut membership: &fidl_fuchsia_posix_socket::IpMulticastMembership,
3709    ) -> fidl::client::QueryResponseFut<
3710        fidl_fuchsia_posix_socket::BaseNetworkSocketDropIpMembershipResult,
3711        fidl::encoding::DefaultFuchsiaResourceDialect,
3712    > {
3713        SocketProxyInterface::r#drop_ip_membership(self, membership)
3714    }
3715
3716    /// Set `SOL_IP` -> `IP_TRANSPARENT`
3717    pub fn r#set_ip_transparent(
3718        &self,
3719        mut value: bool,
3720    ) -> fidl::client::QueryResponseFut<
3721        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTransparentResult,
3722        fidl::encoding::DefaultFuchsiaResourceDialect,
3723    > {
3724        SocketProxyInterface::r#set_ip_transparent(self, value)
3725    }
3726
3727    /// Get `SOL_IP` -> `IP_TRANSPARENT`
3728    pub fn r#get_ip_transparent(
3729        &self,
3730    ) -> fidl::client::QueryResponseFut<
3731        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTransparentResult,
3732        fidl::encoding::DefaultFuchsiaResourceDialect,
3733    > {
3734        SocketProxyInterface::r#get_ip_transparent(self)
3735    }
3736
3737    /// Set `SOL_IP` -> `IP_RECVORIGDSTADDR`
3738    pub fn r#set_ip_receive_original_destination_address(
3739        &self,
3740        mut value: bool,
3741    ) -> fidl::client::QueryResponseFut<
3742        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
3743        fidl::encoding::DefaultFuchsiaResourceDialect,
3744    > {
3745        SocketProxyInterface::r#set_ip_receive_original_destination_address(self, value)
3746    }
3747
3748    /// Get `SOL_IP` -> `IP_RECVORIGDSTADDR`
3749    pub fn r#get_ip_receive_original_destination_address(
3750        &self,
3751    ) -> fidl::client::QueryResponseFut<
3752        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
3753        fidl::encoding::DefaultFuchsiaResourceDialect,
3754    > {
3755        SocketProxyInterface::r#get_ip_receive_original_destination_address(self)
3756    }
3757
3758    /// Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`.
3759    pub fn r#add_ipv6_membership(
3760        &self,
3761        mut membership: &fidl_fuchsia_posix_socket::Ipv6MulticastMembership,
3762    ) -> fidl::client::QueryResponseFut<
3763        fidl_fuchsia_posix_socket::BaseNetworkSocketAddIpv6MembershipResult,
3764        fidl::encoding::DefaultFuchsiaResourceDialect,
3765    > {
3766        SocketProxyInterface::r#add_ipv6_membership(self, membership)
3767    }
3768
3769    /// Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`.
3770    pub fn r#drop_ipv6_membership(
3771        &self,
3772        mut membership: &fidl_fuchsia_posix_socket::Ipv6MulticastMembership,
3773    ) -> fidl::client::QueryResponseFut<
3774        fidl_fuchsia_posix_socket::BaseNetworkSocketDropIpv6MembershipResult,
3775        fidl::encoding::DefaultFuchsiaResourceDialect,
3776    > {
3777        SocketProxyInterface::r#drop_ipv6_membership(self, membership)
3778    }
3779
3780    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
3781    pub fn r#set_ipv6_multicast_interface(
3782        &self,
3783        mut value: u64,
3784    ) -> fidl::client::QueryResponseFut<
3785        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastInterfaceResult,
3786        fidl::encoding::DefaultFuchsiaResourceDialect,
3787    > {
3788        SocketProxyInterface::r#set_ipv6_multicast_interface(self, value)
3789    }
3790
3791    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
3792    pub fn r#get_ipv6_multicast_interface(
3793        &self,
3794    ) -> fidl::client::QueryResponseFut<
3795        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastInterfaceResult,
3796        fidl::encoding::DefaultFuchsiaResourceDialect,
3797    > {
3798        SocketProxyInterface::r#get_ipv6_multicast_interface(self)
3799    }
3800
3801    /// Set `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
3802    pub fn r#set_ipv6_unicast_hops(
3803        &self,
3804        mut value: &fidl_fuchsia_posix_socket::OptionalUint8,
3805    ) -> fidl::client::QueryResponseFut<
3806        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6UnicastHopsResult,
3807        fidl::encoding::DefaultFuchsiaResourceDialect,
3808    > {
3809        SocketProxyInterface::r#set_ipv6_unicast_hops(self, value)
3810    }
3811
3812    /// Get `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
3813    pub fn r#get_ipv6_unicast_hops(
3814        &self,
3815    ) -> fidl::client::QueryResponseFut<
3816        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6UnicastHopsResult,
3817        fidl::encoding::DefaultFuchsiaResourceDialect,
3818    > {
3819        SocketProxyInterface::r#get_ipv6_unicast_hops(self)
3820    }
3821
3822    /// Set `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
3823    pub fn r#set_ipv6_receive_hop_limit(
3824        &self,
3825        mut value: bool,
3826    ) -> fidl::client::QueryResponseFut<
3827        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
3828        fidl::encoding::DefaultFuchsiaResourceDialect,
3829    > {
3830        SocketProxyInterface::r#set_ipv6_receive_hop_limit(self, value)
3831    }
3832
3833    /// Get `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
3834    pub fn r#get_ipv6_receive_hop_limit(
3835        &self,
3836    ) -> fidl::client::QueryResponseFut<
3837        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
3838        fidl::encoding::DefaultFuchsiaResourceDialect,
3839    > {
3840        SocketProxyInterface::r#get_ipv6_receive_hop_limit(self)
3841    }
3842
3843    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
3844    pub fn r#set_ipv6_multicast_hops(
3845        &self,
3846        mut value: &fidl_fuchsia_posix_socket::OptionalUint8,
3847    ) -> fidl::client::QueryResponseFut<
3848        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastHopsResult,
3849        fidl::encoding::DefaultFuchsiaResourceDialect,
3850    > {
3851        SocketProxyInterface::r#set_ipv6_multicast_hops(self, value)
3852    }
3853
3854    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
3855    pub fn r#get_ipv6_multicast_hops(
3856        &self,
3857    ) -> fidl::client::QueryResponseFut<
3858        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastHopsResult,
3859        fidl::encoding::DefaultFuchsiaResourceDialect,
3860    > {
3861        SocketProxyInterface::r#get_ipv6_multicast_hops(self)
3862    }
3863
3864    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
3865    pub fn r#set_ipv6_multicast_loopback(
3866        &self,
3867        mut value: bool,
3868    ) -> fidl::client::QueryResponseFut<
3869        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastLoopbackResult,
3870        fidl::encoding::DefaultFuchsiaResourceDialect,
3871    > {
3872        SocketProxyInterface::r#set_ipv6_multicast_loopback(self, value)
3873    }
3874
3875    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
3876    pub fn r#get_ipv6_multicast_loopback(
3877        &self,
3878    ) -> fidl::client::QueryResponseFut<
3879        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastLoopbackResult,
3880        fidl::encoding::DefaultFuchsiaResourceDialect,
3881    > {
3882        SocketProxyInterface::r#get_ipv6_multicast_loopback(self)
3883    }
3884
3885    /// Set `SOL_IPV6` -> `IPV6_V6ONLY`.
3886    pub fn r#set_ipv6_only(
3887        &self,
3888        mut value: bool,
3889    ) -> fidl::client::QueryResponseFut<
3890        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6OnlyResult,
3891        fidl::encoding::DefaultFuchsiaResourceDialect,
3892    > {
3893        SocketProxyInterface::r#set_ipv6_only(self, value)
3894    }
3895
3896    /// Get `SOL_IPV6` -> `IPV6_V6ONLY`.
3897    pub fn r#get_ipv6_only(
3898        &self,
3899    ) -> fidl::client::QueryResponseFut<
3900        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6OnlyResult,
3901        fidl::encoding::DefaultFuchsiaResourceDialect,
3902    > {
3903        SocketProxyInterface::r#get_ipv6_only(self)
3904    }
3905
3906    /// Set `SOL_IPV6` -> `IPV6_RECVTCLASS`.
3907    pub fn r#set_ipv6_receive_traffic_class(
3908        &self,
3909        mut value: bool,
3910    ) -> fidl::client::QueryResponseFut<
3911        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
3912        fidl::encoding::DefaultFuchsiaResourceDialect,
3913    > {
3914        SocketProxyInterface::r#set_ipv6_receive_traffic_class(self, value)
3915    }
3916
3917    /// Get `SOL_IPV6` -> `IPV6_RECVTCLASS`.
3918    pub fn r#get_ipv6_receive_traffic_class(
3919        &self,
3920    ) -> fidl::client::QueryResponseFut<
3921        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
3922        fidl::encoding::DefaultFuchsiaResourceDialect,
3923    > {
3924        SocketProxyInterface::r#get_ipv6_receive_traffic_class(self)
3925    }
3926
3927    /// Set `SOL_IPV6` -> `IPV6_TCLASS`
3928    pub fn r#set_ipv6_traffic_class(
3929        &self,
3930        mut value: &fidl_fuchsia_posix_socket::OptionalUint8,
3931    ) -> fidl::client::QueryResponseFut<
3932        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6TrafficClassResult,
3933        fidl::encoding::DefaultFuchsiaResourceDialect,
3934    > {
3935        SocketProxyInterface::r#set_ipv6_traffic_class(self, value)
3936    }
3937
3938    /// Get `SOL_IPV6` -> `IPV6_TCLASS`.
3939    pub fn r#get_ipv6_traffic_class(
3940        &self,
3941    ) -> fidl::client::QueryResponseFut<
3942        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6TrafficClassResult,
3943        fidl::encoding::DefaultFuchsiaResourceDialect,
3944    > {
3945        SocketProxyInterface::r#get_ipv6_traffic_class(self)
3946    }
3947
3948    /// Set `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
3949    pub fn r#set_ipv6_receive_packet_info(
3950        &self,
3951        mut value: bool,
3952    ) -> fidl::client::QueryResponseFut<
3953        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
3954        fidl::encoding::DefaultFuchsiaResourceDialect,
3955    > {
3956        SocketProxyInterface::r#set_ipv6_receive_packet_info(self, value)
3957    }
3958
3959    /// Get `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
3960    pub fn r#get_ipv6_receive_packet_info(
3961        &self,
3962    ) -> fidl::client::QueryResponseFut<
3963        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
3964        fidl::encoding::DefaultFuchsiaResourceDialect,
3965    > {
3966        SocketProxyInterface::r#get_ipv6_receive_packet_info(self)
3967    }
3968
3969    /// Get `SOL_IP` -> `SO_ORIGINAL_DST`.
3970    pub fn r#get_original_destination(
3971        &self,
3972    ) -> fidl::client::QueryResponseFut<
3973        fidl_fuchsia_posix_socket::BaseNetworkSocketGetOriginalDestinationResult,
3974        fidl::encoding::DefaultFuchsiaResourceDialect,
3975    > {
3976        SocketProxyInterface::r#get_original_destination(self)
3977    }
3978
3979    pub fn r#describe(
3980        &self,
3981    ) -> fidl::client::QueryResponseFut<
3982        SocketDescribeResponse,
3983        fidl::encoding::DefaultFuchsiaResourceDialect,
3984    > {
3985        SocketProxyInterface::r#describe(self)
3986    }
3987
3988    /// Receives a message from the socket.
3989    ///
3990    /// + request `want_addr` request message's source address information to
3991    ///   be returned.
3992    /// + request `data_len` the maximum allowed length of the response data
3993    ///   buffer.
3994    /// + request `want_control` request ancillary data to be returned.
3995    /// + request `flags` flags for the receive request.
3996    /// - response `addr` the message's source address information, if
3997    ///   requested.
3998    /// - response `data` the message.
3999    /// - response `control` control messages, if requested.
4000    /// - response `truncated` indicates whether or not the returned message
4001    ///   was truncated.
4002    pub fn r#recv_msg(
4003        &self,
4004        mut want_addr: bool,
4005        mut data_len: u32,
4006        mut want_control: bool,
4007        mut flags: fidl_fuchsia_posix_socket::RecvMsgFlags,
4008    ) -> fidl::client::QueryResponseFut<
4009        SocketRecvMsgResult,
4010        fidl::encoding::DefaultFuchsiaResourceDialect,
4011    > {
4012        SocketProxyInterface::r#recv_msg(self, want_addr, data_len, want_control, flags)
4013    }
4014
4015    /// Sends a message on the socket.
4016    ///
4017    /// + request `addr` the address to send the message to. If unset, will
4018    ///   send to the connected peer.
4019    /// + request `data` the message.
4020    /// + request `control` ancillary data.
4021    /// + request `flags` flags for the send request.
4022    pub fn r#send_msg(
4023        &self,
4024        mut addr: Option<&fidl_fuchsia_net::SocketAddress>,
4025        mut data: &[u8],
4026        mut control: &fidl_fuchsia_posix_socket::NetworkSocketSendControlData,
4027        mut flags: fidl_fuchsia_posix_socket::SendMsgFlags,
4028    ) -> fidl::client::QueryResponseFut<
4029        SocketSendMsgResult,
4030        fidl::encoding::DefaultFuchsiaResourceDialect,
4031    > {
4032        SocketProxyInterface::r#send_msg(self, addr, data, control, flags)
4033    }
4034
4035    /// Retrieves creation information from the socket.
4036    ///
4037    /// - response `domain` the socket's associated domain.
4038    /// - response `proto` the socket's associated protocol.
4039    pub fn r#get_info(
4040        &self,
4041    ) -> fidl::client::QueryResponseFut<
4042        SocketGetInfoResult,
4043        fidl::encoding::DefaultFuchsiaResourceDialect,
4044    > {
4045        SocketProxyInterface::r#get_info(self)
4046    }
4047
4048    /// Set `SOL_IP` -> `IP_HDRINCL`.
4049    pub fn r#set_ip_header_included(
4050        &self,
4051        mut value: bool,
4052    ) -> fidl::client::QueryResponseFut<
4053        SocketSetIpHeaderIncludedResult,
4054        fidl::encoding::DefaultFuchsiaResourceDialect,
4055    > {
4056        SocketProxyInterface::r#set_ip_header_included(self, value)
4057    }
4058
4059    /// Get `SOL_IP` -> `IP_HDRINCL`.
4060    pub fn r#get_ip_header_included(
4061        &self,
4062    ) -> fidl::client::QueryResponseFut<
4063        SocketGetIpHeaderIncludedResult,
4064        fidl::encoding::DefaultFuchsiaResourceDialect,
4065    > {
4066        SocketProxyInterface::r#get_ip_header_included(self)
4067    }
4068
4069    /// Set `SOL_ICMPV6` -> `ICMP6_FILTER`.
4070    pub fn r#set_icmpv6_filter(
4071        &self,
4072        mut filter: &Icmpv6Filter,
4073    ) -> fidl::client::QueryResponseFut<
4074        SocketSetIcmpv6FilterResult,
4075        fidl::encoding::DefaultFuchsiaResourceDialect,
4076    > {
4077        SocketProxyInterface::r#set_icmpv6_filter(self, filter)
4078    }
4079
4080    /// Get `SOL_ICMPV6` -> `ICMP6_FILTER`.
4081    pub fn r#get_icmpv6_filter(
4082        &self,
4083    ) -> fidl::client::QueryResponseFut<
4084        SocketGetIcmpv6FilterResult,
4085        fidl::encoding::DefaultFuchsiaResourceDialect,
4086    > {
4087        SocketProxyInterface::r#get_icmpv6_filter(self)
4088    }
4089
4090    /// Set `SOL_IPV6` -> `IPV6_CHECKSUM`.
4091    pub fn r#set_ipv6_checksum(
4092        &self,
4093        mut config: &Ipv6ChecksumConfiguration,
4094    ) -> fidl::client::QueryResponseFut<
4095        SocketSetIpv6ChecksumResult,
4096        fidl::encoding::DefaultFuchsiaResourceDialect,
4097    > {
4098        SocketProxyInterface::r#set_ipv6_checksum(self, config)
4099    }
4100
4101    /// Get `SOL_IPV6` -> `IPV6_CHECKSUM`.
4102    pub fn r#get_ipv6_checksum(
4103        &self,
4104    ) -> fidl::client::QueryResponseFut<
4105        SocketGetIpv6ChecksumResult,
4106        fidl::encoding::DefaultFuchsiaResourceDialect,
4107    > {
4108        SocketProxyInterface::r#get_ipv6_checksum(self)
4109    }
4110}
4111
4112impl SocketProxyInterface for SocketProxy {
4113    fn r#clone(
4114        &self,
4115        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
4116    ) -> Result<(), fidl::Error> {
4117        self.client.send::<fidl_fuchsia_unknown::CloneableCloneRequest>(
4118            (request,),
4119            0x20d8a7aba2168a79,
4120            fidl::encoding::DynamicFlags::empty(),
4121        )
4122    }
4123
4124    type CloseResponseFut = fidl::client::QueryResponseFut<
4125        fidl_fuchsia_unknown::CloseableCloseResult,
4126        fidl::encoding::DefaultFuchsiaResourceDialect,
4127    >;
4128    fn r#close(&self) -> Self::CloseResponseFut {
4129        fn _decode(
4130            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4131        ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
4132            let _response = fidl::client::decode_transaction_body::<
4133                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
4134                fidl::encoding::DefaultFuchsiaResourceDialect,
4135                0x5ac5d459ad7f657e,
4136            >(_buf?)?;
4137            Ok(_response.map(|x| x))
4138        }
4139        self.client.send_query_and_decode::<
4140            fidl::encoding::EmptyPayload,
4141            fidl_fuchsia_unknown::CloseableCloseResult,
4142        >(
4143            (),
4144            0x5ac5d459ad7f657e,
4145            fidl::encoding::DynamicFlags::empty(),
4146            _decode,
4147        )
4148    }
4149
4150    type QueryResponseFut =
4151        fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>;
4152    fn r#query(&self) -> Self::QueryResponseFut {
4153        fn _decode(
4154            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4155        ) -> Result<Vec<u8>, fidl::Error> {
4156            let _response = fidl::client::decode_transaction_body::<
4157                fidl_fuchsia_unknown::QueryableQueryResponse,
4158                fidl::encoding::DefaultFuchsiaResourceDialect,
4159                0x2658edee9decfc06,
4160            >(_buf?)?;
4161            Ok(_response.protocol)
4162        }
4163        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<u8>>(
4164            (),
4165            0x2658edee9decfc06,
4166            fidl::encoding::DynamicFlags::empty(),
4167            _decode,
4168        )
4169    }
4170
4171    type SetReuseAddressResponseFut = fidl::client::QueryResponseFut<
4172        fidl_fuchsia_posix_socket::BaseSocketSetReuseAddressResult,
4173        fidl::encoding::DefaultFuchsiaResourceDialect,
4174    >;
4175    fn r#set_reuse_address(&self, mut value: bool) -> Self::SetReuseAddressResponseFut {
4176        fn _decode(
4177            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4178        ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetReuseAddressResult, fidl::Error>
4179        {
4180            let _response = fidl::client::decode_transaction_body::<
4181                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4182                fidl::encoding::DefaultFuchsiaResourceDialect,
4183                0x1fd74ee8b9a4a876,
4184            >(_buf?)?;
4185            Ok(_response.map(|x| x))
4186        }
4187        self.client.send_query_and_decode::<
4188            fidl_fuchsia_posix_socket::BaseSocketSetReuseAddressRequest,
4189            fidl_fuchsia_posix_socket::BaseSocketSetReuseAddressResult,
4190        >(
4191            (value,),
4192            0x1fd74ee8b9a4a876,
4193            fidl::encoding::DynamicFlags::empty(),
4194            _decode,
4195        )
4196    }
4197
4198    type GetReuseAddressResponseFut = fidl::client::QueryResponseFut<
4199        fidl_fuchsia_posix_socket::BaseSocketGetReuseAddressResult,
4200        fidl::encoding::DefaultFuchsiaResourceDialect,
4201    >;
4202    fn r#get_reuse_address(&self) -> Self::GetReuseAddressResponseFut {
4203        fn _decode(
4204            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4205        ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetReuseAddressResult, fidl::Error>
4206        {
4207            let _response = fidl::client::decode_transaction_body::<
4208                fidl::encoding::ResultType<
4209                    fidl_fuchsia_posix_socket::BaseSocketGetReuseAddressResponse,
4210                    fidl_fuchsia_posix::Errno,
4211                >,
4212                fidl::encoding::DefaultFuchsiaResourceDialect,
4213                0x67b7206b8d1bc0a5,
4214            >(_buf?)?;
4215            Ok(_response.map(|x| x.value))
4216        }
4217        self.client.send_query_and_decode::<
4218            fidl::encoding::EmptyPayload,
4219            fidl_fuchsia_posix_socket::BaseSocketGetReuseAddressResult,
4220        >(
4221            (),
4222            0x67b7206b8d1bc0a5,
4223            fidl::encoding::DynamicFlags::empty(),
4224            _decode,
4225        )
4226    }
4227
4228    type GetErrorResponseFut = fidl::client::QueryResponseFut<
4229        fidl_fuchsia_posix_socket::BaseSocketGetErrorResult,
4230        fidl::encoding::DefaultFuchsiaResourceDialect,
4231    >;
4232    fn r#get_error(&self) -> Self::GetErrorResponseFut {
4233        fn _decode(
4234            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4235        ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetErrorResult, fidl::Error> {
4236            let _response = fidl::client::decode_transaction_body::<
4237                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4238                fidl::encoding::DefaultFuchsiaResourceDialect,
4239                0x5aad39b33e5f6ebb,
4240            >(_buf?)?;
4241            Ok(_response.map(|x| x))
4242        }
4243        self.client.send_query_and_decode::<
4244            fidl::encoding::EmptyPayload,
4245            fidl_fuchsia_posix_socket::BaseSocketGetErrorResult,
4246        >(
4247            (),
4248            0x5aad39b33e5f6ebb,
4249            fidl::encoding::DynamicFlags::empty(),
4250            _decode,
4251        )
4252    }
4253
4254    type SetBroadcastResponseFut = fidl::client::QueryResponseFut<
4255        fidl_fuchsia_posix_socket::BaseSocketSetBroadcastResult,
4256        fidl::encoding::DefaultFuchsiaResourceDialect,
4257    >;
4258    fn r#set_broadcast(&self, mut value: bool) -> Self::SetBroadcastResponseFut {
4259        fn _decode(
4260            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4261        ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetBroadcastResult, fidl::Error> {
4262            let _response = fidl::client::decode_transaction_body::<
4263                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4264                fidl::encoding::DefaultFuchsiaResourceDialect,
4265                0x6023e081ce3cd947,
4266            >(_buf?)?;
4267            Ok(_response.map(|x| x))
4268        }
4269        self.client.send_query_and_decode::<
4270            fidl_fuchsia_posix_socket::BaseSocketSetBroadcastRequest,
4271            fidl_fuchsia_posix_socket::BaseSocketSetBroadcastResult,
4272        >(
4273            (value,),
4274            0x6023e081ce3cd947,
4275            fidl::encoding::DynamicFlags::empty(),
4276            _decode,
4277        )
4278    }
4279
4280    type GetBroadcastResponseFut = fidl::client::QueryResponseFut<
4281        fidl_fuchsia_posix_socket::BaseSocketGetBroadcastResult,
4282        fidl::encoding::DefaultFuchsiaResourceDialect,
4283    >;
4284    fn r#get_broadcast(&self) -> Self::GetBroadcastResponseFut {
4285        fn _decode(
4286            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4287        ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetBroadcastResult, fidl::Error> {
4288            let _response = fidl::client::decode_transaction_body::<
4289                fidl::encoding::ResultType<
4290                    fidl_fuchsia_posix_socket::BaseSocketGetBroadcastResponse,
4291                    fidl_fuchsia_posix::Errno,
4292                >,
4293                fidl::encoding::DefaultFuchsiaResourceDialect,
4294                0x68796fc556f9780d,
4295            >(_buf?)?;
4296            Ok(_response.map(|x| x.value))
4297        }
4298        self.client.send_query_and_decode::<
4299            fidl::encoding::EmptyPayload,
4300            fidl_fuchsia_posix_socket::BaseSocketGetBroadcastResult,
4301        >(
4302            (),
4303            0x68796fc556f9780d,
4304            fidl::encoding::DynamicFlags::empty(),
4305            _decode,
4306        )
4307    }
4308
4309    type SetSendBufferResponseFut = fidl::client::QueryResponseFut<
4310        fidl_fuchsia_posix_socket::BaseSocketSetSendBufferResult,
4311        fidl::encoding::DefaultFuchsiaResourceDialect,
4312    >;
4313    fn r#set_send_buffer(&self, mut value_bytes: u64) -> Self::SetSendBufferResponseFut {
4314        fn _decode(
4315            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4316        ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetSendBufferResult, fidl::Error> {
4317            let _response = fidl::client::decode_transaction_body::<
4318                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4319                fidl::encoding::DefaultFuchsiaResourceDialect,
4320                0x756eac32d73a7a70,
4321            >(_buf?)?;
4322            Ok(_response.map(|x| x))
4323        }
4324        self.client.send_query_and_decode::<
4325            fidl_fuchsia_posix_socket::BaseSocketSetSendBufferRequest,
4326            fidl_fuchsia_posix_socket::BaseSocketSetSendBufferResult,
4327        >(
4328            (value_bytes,),
4329            0x756eac32d73a7a70,
4330            fidl::encoding::DynamicFlags::empty(),
4331            _decode,
4332        )
4333    }
4334
4335    type GetSendBufferResponseFut = fidl::client::QueryResponseFut<
4336        fidl_fuchsia_posix_socket::BaseSocketGetSendBufferResult,
4337        fidl::encoding::DefaultFuchsiaResourceDialect,
4338    >;
4339    fn r#get_send_buffer(&self) -> Self::GetSendBufferResponseFut {
4340        fn _decode(
4341            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4342        ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetSendBufferResult, fidl::Error> {
4343            let _response = fidl::client::decode_transaction_body::<
4344                fidl::encoding::ResultType<
4345                    fidl_fuchsia_posix_socket::BaseSocketGetSendBufferResponse,
4346                    fidl_fuchsia_posix::Errno,
4347                >,
4348                fidl::encoding::DefaultFuchsiaResourceDialect,
4349                0x78a52fd9c7b2410b,
4350            >(_buf?)?;
4351            Ok(_response.map(|x| x.value_bytes))
4352        }
4353        self.client.send_query_and_decode::<
4354            fidl::encoding::EmptyPayload,
4355            fidl_fuchsia_posix_socket::BaseSocketGetSendBufferResult,
4356        >(
4357            (),
4358            0x78a52fd9c7b2410b,
4359            fidl::encoding::DynamicFlags::empty(),
4360            _decode,
4361        )
4362    }
4363
4364    type SetReceiveBufferResponseFut = fidl::client::QueryResponseFut<
4365        fidl_fuchsia_posix_socket::BaseSocketSetReceiveBufferResult,
4366        fidl::encoding::DefaultFuchsiaResourceDialect,
4367    >;
4368    fn r#set_receive_buffer(&self, mut value_bytes: u64) -> Self::SetReceiveBufferResponseFut {
4369        fn _decode(
4370            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4371        ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetReceiveBufferResult, fidl::Error>
4372        {
4373            let _response = fidl::client::decode_transaction_body::<
4374                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4375                fidl::encoding::DefaultFuchsiaResourceDialect,
4376                0x6b0cf2f1919c7001,
4377            >(_buf?)?;
4378            Ok(_response.map(|x| x))
4379        }
4380        self.client.send_query_and_decode::<
4381            fidl_fuchsia_posix_socket::BaseSocketSetReceiveBufferRequest,
4382            fidl_fuchsia_posix_socket::BaseSocketSetReceiveBufferResult,
4383        >(
4384            (value_bytes,),
4385            0x6b0cf2f1919c7001,
4386            fidl::encoding::DynamicFlags::empty(),
4387            _decode,
4388        )
4389    }
4390
4391    type GetReceiveBufferResponseFut = fidl::client::QueryResponseFut<
4392        fidl_fuchsia_posix_socket::BaseSocketGetReceiveBufferResult,
4393        fidl::encoding::DefaultFuchsiaResourceDialect,
4394    >;
4395    fn r#get_receive_buffer(&self) -> Self::GetReceiveBufferResponseFut {
4396        fn _decode(
4397            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4398        ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetReceiveBufferResult, fidl::Error>
4399        {
4400            let _response = fidl::client::decode_transaction_body::<
4401                fidl::encoding::ResultType<
4402                    fidl_fuchsia_posix_socket::BaseSocketGetReceiveBufferResponse,
4403                    fidl_fuchsia_posix::Errno,
4404                >,
4405                fidl::encoding::DefaultFuchsiaResourceDialect,
4406                0x14c1a4b64f709e5c,
4407            >(_buf?)?;
4408            Ok(_response.map(|x| x.value_bytes))
4409        }
4410        self.client.send_query_and_decode::<
4411            fidl::encoding::EmptyPayload,
4412            fidl_fuchsia_posix_socket::BaseSocketGetReceiveBufferResult,
4413        >(
4414            (),
4415            0x14c1a4b64f709e5c,
4416            fidl::encoding::DynamicFlags::empty(),
4417            _decode,
4418        )
4419    }
4420
4421    type SetKeepAliveResponseFut = fidl::client::QueryResponseFut<
4422        fidl_fuchsia_posix_socket::BaseSocketSetKeepAliveResult,
4423        fidl::encoding::DefaultFuchsiaResourceDialect,
4424    >;
4425    fn r#set_keep_alive(&self, mut value: bool) -> Self::SetKeepAliveResponseFut {
4426        fn _decode(
4427            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4428        ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetKeepAliveResult, fidl::Error> {
4429            let _response = fidl::client::decode_transaction_body::<
4430                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4431                fidl::encoding::DefaultFuchsiaResourceDialect,
4432                0x572df8f0b920d2c7,
4433            >(_buf?)?;
4434            Ok(_response.map(|x| x))
4435        }
4436        self.client.send_query_and_decode::<
4437            fidl_fuchsia_posix_socket::BaseSocketSetKeepAliveRequest,
4438            fidl_fuchsia_posix_socket::BaseSocketSetKeepAliveResult,
4439        >(
4440            (value,),
4441            0x572df8f0b920d2c7,
4442            fidl::encoding::DynamicFlags::empty(),
4443            _decode,
4444        )
4445    }
4446
4447    type GetKeepAliveResponseFut = fidl::client::QueryResponseFut<
4448        fidl_fuchsia_posix_socket::BaseSocketGetKeepAliveResult,
4449        fidl::encoding::DefaultFuchsiaResourceDialect,
4450    >;
4451    fn r#get_keep_alive(&self) -> Self::GetKeepAliveResponseFut {
4452        fn _decode(
4453            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4454        ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetKeepAliveResult, fidl::Error> {
4455            let _response = fidl::client::decode_transaction_body::<
4456                fidl::encoding::ResultType<
4457                    fidl_fuchsia_posix_socket::BaseSocketGetKeepAliveResponse,
4458                    fidl_fuchsia_posix::Errno,
4459                >,
4460                fidl::encoding::DefaultFuchsiaResourceDialect,
4461                0x2dd29d3215f2c9d2,
4462            >(_buf?)?;
4463            Ok(_response.map(|x| x.value))
4464        }
4465        self.client.send_query_and_decode::<
4466            fidl::encoding::EmptyPayload,
4467            fidl_fuchsia_posix_socket::BaseSocketGetKeepAliveResult,
4468        >(
4469            (),
4470            0x2dd29d3215f2c9d2,
4471            fidl::encoding::DynamicFlags::empty(),
4472            _decode,
4473        )
4474    }
4475
4476    type SetOutOfBandInlineResponseFut = fidl::client::QueryResponseFut<
4477        fidl_fuchsia_posix_socket::BaseSocketSetOutOfBandInlineResult,
4478        fidl::encoding::DefaultFuchsiaResourceDialect,
4479    >;
4480    fn r#set_out_of_band_inline(&self, mut value: bool) -> Self::SetOutOfBandInlineResponseFut {
4481        fn _decode(
4482            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4483        ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetOutOfBandInlineResult, fidl::Error>
4484        {
4485            let _response = fidl::client::decode_transaction_body::<
4486                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4487                fidl::encoding::DefaultFuchsiaResourceDialect,
4488                0x3ecb49968bee439,
4489            >(_buf?)?;
4490            Ok(_response.map(|x| x))
4491        }
4492        self.client.send_query_and_decode::<
4493            fidl_fuchsia_posix_socket::BaseSocketSetOutOfBandInlineRequest,
4494            fidl_fuchsia_posix_socket::BaseSocketSetOutOfBandInlineResult,
4495        >(
4496            (value,),
4497            0x3ecb49968bee439,
4498            fidl::encoding::DynamicFlags::empty(),
4499            _decode,
4500        )
4501    }
4502
4503    type GetOutOfBandInlineResponseFut = fidl::client::QueryResponseFut<
4504        fidl_fuchsia_posix_socket::BaseSocketGetOutOfBandInlineResult,
4505        fidl::encoding::DefaultFuchsiaResourceDialect,
4506    >;
4507    fn r#get_out_of_band_inline(&self) -> Self::GetOutOfBandInlineResponseFut {
4508        fn _decode(
4509            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4510        ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetOutOfBandInlineResult, fidl::Error>
4511        {
4512            let _response = fidl::client::decode_transaction_body::<
4513                fidl::encoding::ResultType<
4514                    fidl_fuchsia_posix_socket::BaseSocketGetOutOfBandInlineResponse,
4515                    fidl_fuchsia_posix::Errno,
4516                >,
4517                fidl::encoding::DefaultFuchsiaResourceDialect,
4518                0x348c1ab3aeca1745,
4519            >(_buf?)?;
4520            Ok(_response.map(|x| x.value))
4521        }
4522        self.client.send_query_and_decode::<
4523            fidl::encoding::EmptyPayload,
4524            fidl_fuchsia_posix_socket::BaseSocketGetOutOfBandInlineResult,
4525        >(
4526            (),
4527            0x348c1ab3aeca1745,
4528            fidl::encoding::DynamicFlags::empty(),
4529            _decode,
4530        )
4531    }
4532
4533    type SetNoCheckResponseFut = fidl::client::QueryResponseFut<
4534        fidl_fuchsia_posix_socket::BaseSocketSetNoCheckResult,
4535        fidl::encoding::DefaultFuchsiaResourceDialect,
4536    >;
4537    fn r#set_no_check(&self, mut value: bool) -> Self::SetNoCheckResponseFut {
4538        fn _decode(
4539            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4540        ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetNoCheckResult, fidl::Error> {
4541            let _response = fidl::client::decode_transaction_body::<
4542                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4543                fidl::encoding::DefaultFuchsiaResourceDialect,
4544                0x6bbf00c53a4c78c2,
4545            >(_buf?)?;
4546            Ok(_response.map(|x| x))
4547        }
4548        self.client.send_query_and_decode::<
4549            fidl_fuchsia_posix_socket::BaseSocketSetNoCheckRequest,
4550            fidl_fuchsia_posix_socket::BaseSocketSetNoCheckResult,
4551        >(
4552            (value,),
4553            0x6bbf00c53a4c78c2,
4554            fidl::encoding::DynamicFlags::empty(),
4555            _decode,
4556        )
4557    }
4558
4559    type GetNoCheckResponseFut = fidl::client::QueryResponseFut<
4560        fidl_fuchsia_posix_socket::BaseSocketGetNoCheckResult,
4561        fidl::encoding::DefaultFuchsiaResourceDialect,
4562    >;
4563    fn r#get_no_check(&self) -> Self::GetNoCheckResponseFut {
4564        fn _decode(
4565            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4566        ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetNoCheckResult, fidl::Error> {
4567            let _response = fidl::client::decode_transaction_body::<
4568                fidl::encoding::ResultType<
4569                    fidl_fuchsia_posix_socket::BaseSocketGetNoCheckResponse,
4570                    fidl_fuchsia_posix::Errno,
4571                >,
4572                fidl::encoding::DefaultFuchsiaResourceDialect,
4573                0x2cd4249286417694,
4574            >(_buf?)?;
4575            Ok(_response.map(|x| x.value))
4576        }
4577        self.client.send_query_and_decode::<
4578            fidl::encoding::EmptyPayload,
4579            fidl_fuchsia_posix_socket::BaseSocketGetNoCheckResult,
4580        >(
4581            (),
4582            0x2cd4249286417694,
4583            fidl::encoding::DynamicFlags::empty(),
4584            _decode,
4585        )
4586    }
4587
4588    type SetLingerResponseFut = fidl::client::QueryResponseFut<
4589        fidl_fuchsia_posix_socket::BaseSocketSetLingerResult,
4590        fidl::encoding::DefaultFuchsiaResourceDialect,
4591    >;
4592    fn r#set_linger(&self, mut linger: bool, mut length_secs: u32) -> Self::SetLingerResponseFut {
4593        fn _decode(
4594            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4595        ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetLingerResult, fidl::Error> {
4596            let _response = fidl::client::decode_transaction_body::<
4597                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4598                fidl::encoding::DefaultFuchsiaResourceDialect,
4599                0x45386351246e998e,
4600            >(_buf?)?;
4601            Ok(_response.map(|x| x))
4602        }
4603        self.client.send_query_and_decode::<
4604            fidl_fuchsia_posix_socket::BaseSocketSetLingerRequest,
4605            fidl_fuchsia_posix_socket::BaseSocketSetLingerResult,
4606        >(
4607            (linger, length_secs,),
4608            0x45386351246e998e,
4609            fidl::encoding::DynamicFlags::empty(),
4610            _decode,
4611        )
4612    }
4613
4614    type GetLingerResponseFut = fidl::client::QueryResponseFut<
4615        fidl_fuchsia_posix_socket::BaseSocketGetLingerResult,
4616        fidl::encoding::DefaultFuchsiaResourceDialect,
4617    >;
4618    fn r#get_linger(&self) -> Self::GetLingerResponseFut {
4619        fn _decode(
4620            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4621        ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetLingerResult, fidl::Error> {
4622            let _response = fidl::client::decode_transaction_body::<
4623                fidl::encoding::ResultType<
4624                    fidl_fuchsia_posix_socket::BaseSocketGetLingerResponse,
4625                    fidl_fuchsia_posix::Errno,
4626                >,
4627                fidl::encoding::DefaultFuchsiaResourceDialect,
4628                0x48eb20fc5ccb0e45,
4629            >(_buf?)?;
4630            Ok(_response.map(|x| (x.linger, x.length_secs)))
4631        }
4632        self.client.send_query_and_decode::<
4633            fidl::encoding::EmptyPayload,
4634            fidl_fuchsia_posix_socket::BaseSocketGetLingerResult,
4635        >(
4636            (),
4637            0x48eb20fc5ccb0e45,
4638            fidl::encoding::DynamicFlags::empty(),
4639            _decode,
4640        )
4641    }
4642
4643    type SetReusePortResponseFut = fidl::client::QueryResponseFut<
4644        fidl_fuchsia_posix_socket::BaseSocketSetReusePortResult,
4645        fidl::encoding::DefaultFuchsiaResourceDialect,
4646    >;
4647    fn r#set_reuse_port(&self, mut value: bool) -> Self::SetReusePortResponseFut {
4648        fn _decode(
4649            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4650        ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetReusePortResult, fidl::Error> {
4651            let _response = fidl::client::decode_transaction_body::<
4652                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4653                fidl::encoding::DefaultFuchsiaResourceDialect,
4654                0x24dd3e5cb36d9ccb,
4655            >(_buf?)?;
4656            Ok(_response.map(|x| x))
4657        }
4658        self.client.send_query_and_decode::<
4659            fidl_fuchsia_posix_socket::BaseSocketSetReusePortRequest,
4660            fidl_fuchsia_posix_socket::BaseSocketSetReusePortResult,
4661        >(
4662            (value,),
4663            0x24dd3e5cb36d9ccb,
4664            fidl::encoding::DynamicFlags::empty(),
4665            _decode,
4666        )
4667    }
4668
4669    type GetReusePortResponseFut = fidl::client::QueryResponseFut<
4670        fidl_fuchsia_posix_socket::BaseSocketGetReusePortResult,
4671        fidl::encoding::DefaultFuchsiaResourceDialect,
4672    >;
4673    fn r#get_reuse_port(&self) -> Self::GetReusePortResponseFut {
4674        fn _decode(
4675            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4676        ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetReusePortResult, fidl::Error> {
4677            let _response = fidl::client::decode_transaction_body::<
4678                fidl::encoding::ResultType<
4679                    fidl_fuchsia_posix_socket::BaseSocketGetReusePortResponse,
4680                    fidl_fuchsia_posix::Errno,
4681                >,
4682                fidl::encoding::DefaultFuchsiaResourceDialect,
4683                0x7a112c1ab54ff828,
4684            >(_buf?)?;
4685            Ok(_response.map(|x| x.value))
4686        }
4687        self.client.send_query_and_decode::<
4688            fidl::encoding::EmptyPayload,
4689            fidl_fuchsia_posix_socket::BaseSocketGetReusePortResult,
4690        >(
4691            (),
4692            0x7a112c1ab54ff828,
4693            fidl::encoding::DynamicFlags::empty(),
4694            _decode,
4695        )
4696    }
4697
4698    type GetAcceptConnResponseFut = fidl::client::QueryResponseFut<
4699        fidl_fuchsia_posix_socket::BaseSocketGetAcceptConnResult,
4700        fidl::encoding::DefaultFuchsiaResourceDialect,
4701    >;
4702    fn r#get_accept_conn(&self) -> Self::GetAcceptConnResponseFut {
4703        fn _decode(
4704            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4705        ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetAcceptConnResult, fidl::Error> {
4706            let _response = fidl::client::decode_transaction_body::<
4707                fidl::encoding::ResultType<
4708                    fidl_fuchsia_posix_socket::BaseSocketGetAcceptConnResponse,
4709                    fidl_fuchsia_posix::Errno,
4710                >,
4711                fidl::encoding::DefaultFuchsiaResourceDialect,
4712                0x67ce6db6c2ec8966,
4713            >(_buf?)?;
4714            Ok(_response.map(|x| x.value))
4715        }
4716        self.client.send_query_and_decode::<
4717            fidl::encoding::EmptyPayload,
4718            fidl_fuchsia_posix_socket::BaseSocketGetAcceptConnResult,
4719        >(
4720            (),
4721            0x67ce6db6c2ec8966,
4722            fidl::encoding::DynamicFlags::empty(),
4723            _decode,
4724        )
4725    }
4726
4727    type SetBindToDeviceResponseFut = fidl::client::QueryResponseFut<
4728        fidl_fuchsia_posix_socket::BaseSocketSetBindToDeviceResult,
4729        fidl::encoding::DefaultFuchsiaResourceDialect,
4730    >;
4731    fn r#set_bind_to_device(&self, mut value: &str) -> Self::SetBindToDeviceResponseFut {
4732        fn _decode(
4733            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4734        ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetBindToDeviceResult, fidl::Error>
4735        {
4736            let _response = fidl::client::decode_transaction_body::<
4737                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4738                fidl::encoding::DefaultFuchsiaResourceDialect,
4739                0x2118b483f28aafc4,
4740            >(_buf?)?;
4741            Ok(_response.map(|x| x))
4742        }
4743        self.client.send_query_and_decode::<
4744            fidl_fuchsia_posix_socket::BaseSocketSetBindToDeviceRequest,
4745            fidl_fuchsia_posix_socket::BaseSocketSetBindToDeviceResult,
4746        >(
4747            (value,),
4748            0x2118b483f28aafc4,
4749            fidl::encoding::DynamicFlags::empty(),
4750            _decode,
4751        )
4752    }
4753
4754    type GetBindToDeviceResponseFut = fidl::client::QueryResponseFut<
4755        fidl_fuchsia_posix_socket::BaseSocketGetBindToDeviceResult,
4756        fidl::encoding::DefaultFuchsiaResourceDialect,
4757    >;
4758    fn r#get_bind_to_device(&self) -> Self::GetBindToDeviceResponseFut {
4759        fn _decode(
4760            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4761        ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetBindToDeviceResult, fidl::Error>
4762        {
4763            let _response = fidl::client::decode_transaction_body::<
4764                fidl::encoding::ResultType<
4765                    fidl_fuchsia_posix_socket::BaseSocketGetBindToDeviceResponse,
4766                    fidl_fuchsia_posix::Errno,
4767                >,
4768                fidl::encoding::DefaultFuchsiaResourceDialect,
4769                0x1ab1fbf0ef7906c8,
4770            >(_buf?)?;
4771            Ok(_response.map(|x| x.value))
4772        }
4773        self.client.send_query_and_decode::<
4774            fidl::encoding::EmptyPayload,
4775            fidl_fuchsia_posix_socket::BaseSocketGetBindToDeviceResult,
4776        >(
4777            (),
4778            0x1ab1fbf0ef7906c8,
4779            fidl::encoding::DynamicFlags::empty(),
4780            _decode,
4781        )
4782    }
4783
4784    type SetBindToInterfaceIndexResponseFut = fidl::client::QueryResponseFut<
4785        fidl_fuchsia_posix_socket::BaseSocketSetBindToInterfaceIndexResult,
4786        fidl::encoding::DefaultFuchsiaResourceDialect,
4787    >;
4788    fn r#set_bind_to_interface_index(
4789        &self,
4790        mut value: u64,
4791    ) -> Self::SetBindToInterfaceIndexResponseFut {
4792        fn _decode(
4793            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4794        ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetBindToInterfaceIndexResult, fidl::Error>
4795        {
4796            let _response = fidl::client::decode_transaction_body::<
4797                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4798                fidl::encoding::DefaultFuchsiaResourceDialect,
4799                0x6e387a0def00821,
4800            >(_buf?)?;
4801            Ok(_response.map(|x| x))
4802        }
4803        self.client.send_query_and_decode::<
4804            fidl_fuchsia_posix_socket::BaseSocketSetBindToInterfaceIndexRequest,
4805            fidl_fuchsia_posix_socket::BaseSocketSetBindToInterfaceIndexResult,
4806        >(
4807            (value,),
4808            0x6e387a0def00821,
4809            fidl::encoding::DynamicFlags::empty(),
4810            _decode,
4811        )
4812    }
4813
4814    type GetBindToInterfaceIndexResponseFut = fidl::client::QueryResponseFut<
4815        fidl_fuchsia_posix_socket::BaseSocketGetBindToInterfaceIndexResult,
4816        fidl::encoding::DefaultFuchsiaResourceDialect,
4817    >;
4818    fn r#get_bind_to_interface_index(&self) -> Self::GetBindToInterfaceIndexResponseFut {
4819        fn _decode(
4820            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4821        ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetBindToInterfaceIndexResult, fidl::Error>
4822        {
4823            let _response = fidl::client::decode_transaction_body::<
4824                fidl::encoding::ResultType<
4825                    fidl_fuchsia_posix_socket::BaseSocketGetBindToInterfaceIndexResponse,
4826                    fidl_fuchsia_posix::Errno,
4827                >,
4828                fidl::encoding::DefaultFuchsiaResourceDialect,
4829                0x59c31dd3e3078295,
4830            >(_buf?)?;
4831            Ok(_response.map(|x| x.value))
4832        }
4833        self.client.send_query_and_decode::<
4834            fidl::encoding::EmptyPayload,
4835            fidl_fuchsia_posix_socket::BaseSocketGetBindToInterfaceIndexResult,
4836        >(
4837            (),
4838            0x59c31dd3e3078295,
4839            fidl::encoding::DynamicFlags::empty(),
4840            _decode,
4841        )
4842    }
4843
4844    type SetTimestampResponseFut = fidl::client::QueryResponseFut<
4845        fidl_fuchsia_posix_socket::BaseSocketSetTimestampResult,
4846        fidl::encoding::DefaultFuchsiaResourceDialect,
4847    >;
4848    fn r#set_timestamp(
4849        &self,
4850        mut value: fidl_fuchsia_posix_socket::TimestampOption,
4851    ) -> Self::SetTimestampResponseFut {
4852        fn _decode(
4853            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4854        ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetTimestampResult, fidl::Error> {
4855            let _response = fidl::client::decode_transaction_body::<
4856                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4857                fidl::encoding::DefaultFuchsiaResourceDialect,
4858                0x285d6516c263d839,
4859            >(_buf?)?;
4860            Ok(_response.map(|x| x))
4861        }
4862        self.client.send_query_and_decode::<
4863            fidl_fuchsia_posix_socket::BaseSocketSetTimestampRequest,
4864            fidl_fuchsia_posix_socket::BaseSocketSetTimestampResult,
4865        >(
4866            (value,),
4867            0x285d6516c263d839,
4868            fidl::encoding::DynamicFlags::empty(),
4869            _decode,
4870        )
4871    }
4872
4873    type GetTimestampResponseFut = fidl::client::QueryResponseFut<
4874        fidl_fuchsia_posix_socket::BaseSocketGetTimestampResult,
4875        fidl::encoding::DefaultFuchsiaResourceDialect,
4876    >;
4877    fn r#get_timestamp(&self) -> Self::GetTimestampResponseFut {
4878        fn _decode(
4879            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4880        ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetTimestampResult, fidl::Error> {
4881            let _response = fidl::client::decode_transaction_body::<
4882                fidl::encoding::ResultType<
4883                    fidl_fuchsia_posix_socket::BaseSocketGetTimestampResponse,
4884                    fidl_fuchsia_posix::Errno,
4885                >,
4886                fidl::encoding::DefaultFuchsiaResourceDialect,
4887                0x49f2fffbbcc2bd27,
4888            >(_buf?)?;
4889            Ok(_response.map(|x| x.value))
4890        }
4891        self.client.send_query_and_decode::<
4892            fidl::encoding::EmptyPayload,
4893            fidl_fuchsia_posix_socket::BaseSocketGetTimestampResult,
4894        >(
4895            (),
4896            0x49f2fffbbcc2bd27,
4897            fidl::encoding::DynamicFlags::empty(),
4898            _decode,
4899        )
4900    }
4901
4902    type SetMarkResponseFut = fidl::client::QueryResponseFut<
4903        fidl_fuchsia_posix_socket::BaseSocketSetMarkResult,
4904        fidl::encoding::DefaultFuchsiaResourceDialect,
4905    >;
4906    fn r#set_mark(
4907        &self,
4908        mut domain: fidl_fuchsia_net::MarkDomain,
4909        mut mark: &fidl_fuchsia_posix_socket::OptionalUint32,
4910    ) -> Self::SetMarkResponseFut {
4911        fn _decode(
4912            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4913        ) -> Result<fidl_fuchsia_posix_socket::BaseSocketSetMarkResult, fidl::Error> {
4914            let _response = fidl::client::decode_transaction_body::<
4915                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4916                fidl::encoding::DefaultFuchsiaResourceDialect,
4917                0x6ead6de09f653236,
4918            >(_buf?)?;
4919            Ok(_response.map(|x| x))
4920        }
4921        self.client.send_query_and_decode::<
4922            fidl_fuchsia_posix_socket::BaseSocketSetMarkRequest,
4923            fidl_fuchsia_posix_socket::BaseSocketSetMarkResult,
4924        >(
4925            (domain, mark,),
4926            0x6ead6de09f653236,
4927            fidl::encoding::DynamicFlags::empty(),
4928            _decode,
4929        )
4930    }
4931
4932    type GetMarkResponseFut = fidl::client::QueryResponseFut<
4933        fidl_fuchsia_posix_socket::BaseSocketGetMarkResult,
4934        fidl::encoding::DefaultFuchsiaResourceDialect,
4935    >;
4936    fn r#get_mark(&self, mut domain: fidl_fuchsia_net::MarkDomain) -> Self::GetMarkResponseFut {
4937        fn _decode(
4938            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4939        ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetMarkResult, fidl::Error> {
4940            let _response = fidl::client::decode_transaction_body::<
4941                fidl::encoding::ResultType<
4942                    fidl_fuchsia_posix_socket::BaseSocketGetMarkResponse,
4943                    fidl_fuchsia_posix::Errno,
4944                >,
4945                fidl::encoding::DefaultFuchsiaResourceDialect,
4946                0x57a2752c61d93d47,
4947            >(_buf?)?;
4948            Ok(_response.map(|x| x.mark))
4949        }
4950        self.client.send_query_and_decode::<
4951            fidl_fuchsia_posix_socket::BaseSocketGetMarkRequest,
4952            fidl_fuchsia_posix_socket::BaseSocketGetMarkResult,
4953        >(
4954            (domain,),
4955            0x57a2752c61d93d47,
4956            fidl::encoding::DynamicFlags::empty(),
4957            _decode,
4958        )
4959    }
4960
4961    type GetCookieResponseFut = fidl::client::QueryResponseFut<
4962        fidl_fuchsia_posix_socket::BaseSocketGetCookieResult,
4963        fidl::encoding::DefaultFuchsiaResourceDialect,
4964    >;
4965    fn r#get_cookie(&self) -> Self::GetCookieResponseFut {
4966        fn _decode(
4967            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4968        ) -> Result<fidl_fuchsia_posix_socket::BaseSocketGetCookieResult, fidl::Error> {
4969            let _response = fidl::client::decode_transaction_body::<
4970                fidl::encoding::ResultType<
4971                    fidl_fuchsia_posix_socket::BaseSocketGetCookieResponse,
4972                    fidl_fuchsia_posix::Errno,
4973                >,
4974                fidl::encoding::DefaultFuchsiaResourceDialect,
4975                0x2c2f47fd8f924e52,
4976            >(_buf?)?;
4977            Ok(_response.map(|x| x.value))
4978        }
4979        self.client.send_query_and_decode::<
4980            fidl::encoding::EmptyPayload,
4981            fidl_fuchsia_posix_socket::BaseSocketGetCookieResult,
4982        >(
4983            (),
4984            0x2c2f47fd8f924e52,
4985            fidl::encoding::DynamicFlags::empty(),
4986            _decode,
4987        )
4988    }
4989
4990    type BindResponseFut = fidl::client::QueryResponseFut<
4991        fidl_fuchsia_posix_socket::BaseNetworkSocketBindResult,
4992        fidl::encoding::DefaultFuchsiaResourceDialect,
4993    >;
4994    fn r#bind(&self, mut addr: &fidl_fuchsia_net::SocketAddress) -> Self::BindResponseFut {
4995        fn _decode(
4996            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4997        ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketBindResult, fidl::Error> {
4998            let _response = fidl::client::decode_transaction_body::<
4999                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
5000                fidl::encoding::DefaultFuchsiaResourceDialect,
5001                0x4bc6400ae92125d,
5002            >(_buf?)?;
5003            Ok(_response.map(|x| x))
5004        }
5005        self.client.send_query_and_decode::<
5006            fidl_fuchsia_posix_socket::BaseNetworkSocketBindRequest,
5007            fidl_fuchsia_posix_socket::BaseNetworkSocketBindResult,
5008        >(
5009            (addr,),
5010            0x4bc6400ae92125d,
5011            fidl::encoding::DynamicFlags::empty(),
5012            _decode,
5013        )
5014    }
5015
5016    type ConnectResponseFut = fidl::client::QueryResponseFut<
5017        fidl_fuchsia_posix_socket::BaseNetworkSocketConnectResult,
5018        fidl::encoding::DefaultFuchsiaResourceDialect,
5019    >;
5020    fn r#connect(&self, mut addr: &fidl_fuchsia_net::SocketAddress) -> Self::ConnectResponseFut {
5021        fn _decode(
5022            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5023        ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketConnectResult, fidl::Error>
5024        {
5025            let _response = fidl::client::decode_transaction_body::<
5026                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
5027                fidl::encoding::DefaultFuchsiaResourceDialect,
5028                0x5f05f19bfdd38871,
5029            >(_buf?)?;
5030            Ok(_response.map(|x| x))
5031        }
5032        self.client.send_query_and_decode::<
5033            fidl_fuchsia_posix_socket::BaseNetworkSocketConnectRequest,
5034            fidl_fuchsia_posix_socket::BaseNetworkSocketConnectResult,
5035        >(
5036            (addr,),
5037            0x5f05f19bfdd38871,
5038            fidl::encoding::DynamicFlags::empty(),
5039            _decode,
5040        )
5041    }
5042
5043    type DisconnectResponseFut = fidl::client::QueryResponseFut<
5044        fidl_fuchsia_posix_socket::BaseNetworkSocketDisconnectResult,
5045        fidl::encoding::DefaultFuchsiaResourceDialect,
5046    >;
5047    fn r#disconnect(&self) -> Self::DisconnectResponseFut {
5048        fn _decode(
5049            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5050        ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketDisconnectResult, fidl::Error>
5051        {
5052            let _response = fidl::client::decode_transaction_body::<
5053                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
5054                fidl::encoding::DefaultFuchsiaResourceDialect,
5055                0x74e63b91f7b29b2,
5056            >(_buf?)?;
5057            Ok(_response.map(|x| x))
5058        }
5059        self.client.send_query_and_decode::<
5060            fidl::encoding::EmptyPayload,
5061            fidl_fuchsia_posix_socket::BaseNetworkSocketDisconnectResult,
5062        >(
5063            (),
5064            0x74e63b91f7b29b2,
5065            fidl::encoding::DynamicFlags::empty(),
5066            _decode,
5067        )
5068    }
5069
5070    type GetSockNameResponseFut = fidl::client::QueryResponseFut<
5071        fidl_fuchsia_posix_socket::BaseNetworkSocketGetSockNameResult,
5072        fidl::encoding::DefaultFuchsiaResourceDialect,
5073    >;
5074    fn r#get_sock_name(&self) -> Self::GetSockNameResponseFut {
5075        fn _decode(
5076            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5077        ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetSockNameResult, fidl::Error>
5078        {
5079            let _response = fidl::client::decode_transaction_body::<
5080                fidl::encoding::ResultType<
5081                    fidl_fuchsia_posix_socket::BaseNetworkSocketGetSockNameResponse,
5082                    fidl_fuchsia_posix::Errno,
5083                >,
5084                fidl::encoding::DefaultFuchsiaResourceDialect,
5085                0x475f23f84a1a4f85,
5086            >(_buf?)?;
5087            Ok(_response.map(|x| x.addr))
5088        }
5089        self.client.send_query_and_decode::<
5090            fidl::encoding::EmptyPayload,
5091            fidl_fuchsia_posix_socket::BaseNetworkSocketGetSockNameResult,
5092        >(
5093            (),
5094            0x475f23f84a1a4f85,
5095            fidl::encoding::DynamicFlags::empty(),
5096            _decode,
5097        )
5098    }
5099
5100    type GetPeerNameResponseFut = fidl::client::QueryResponseFut<
5101        fidl_fuchsia_posix_socket::BaseNetworkSocketGetPeerNameResult,
5102        fidl::encoding::DefaultFuchsiaResourceDialect,
5103    >;
5104    fn r#get_peer_name(&self) -> Self::GetPeerNameResponseFut {
5105        fn _decode(
5106            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5107        ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetPeerNameResult, fidl::Error>
5108        {
5109            let _response = fidl::client::decode_transaction_body::<
5110                fidl::encoding::ResultType<
5111                    fidl_fuchsia_posix_socket::BaseNetworkSocketGetPeerNameResponse,
5112                    fidl_fuchsia_posix::Errno,
5113                >,
5114                fidl::encoding::DefaultFuchsiaResourceDialect,
5115                0x1ffecf4bd5b6432e,
5116            >(_buf?)?;
5117            Ok(_response.map(|x| x.addr))
5118        }
5119        self.client.send_query_and_decode::<
5120            fidl::encoding::EmptyPayload,
5121            fidl_fuchsia_posix_socket::BaseNetworkSocketGetPeerNameResult,
5122        >(
5123            (),
5124            0x1ffecf4bd5b6432e,
5125            fidl::encoding::DynamicFlags::empty(),
5126            _decode,
5127        )
5128    }
5129
5130    type ShutdownResponseFut = fidl::client::QueryResponseFut<
5131        fidl_fuchsia_posix_socket::BaseNetworkSocketShutdownResult,
5132        fidl::encoding::DefaultFuchsiaResourceDialect,
5133    >;
5134    fn r#shutdown(
5135        &self,
5136        mut mode: fidl_fuchsia_posix_socket::ShutdownMode,
5137    ) -> Self::ShutdownResponseFut {
5138        fn _decode(
5139            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5140        ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketShutdownResult, fidl::Error>
5141        {
5142            let _response = fidl::client::decode_transaction_body::<
5143                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
5144                fidl::encoding::DefaultFuchsiaResourceDialect,
5145                0x247f38b6db68c336,
5146            >(_buf?)?;
5147            Ok(_response.map(|x| x))
5148        }
5149        self.client.send_query_and_decode::<
5150            fidl_fuchsia_posix_socket::BaseNetworkSocketShutdownRequest,
5151            fidl_fuchsia_posix_socket::BaseNetworkSocketShutdownResult,
5152        >(
5153            (mode,),
5154            0x247f38b6db68c336,
5155            fidl::encoding::DynamicFlags::empty(),
5156            _decode,
5157        )
5158    }
5159
5160    type SetIpTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
5161        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTypeOfServiceResult,
5162        fidl::encoding::DefaultFuchsiaResourceDialect,
5163    >;
5164    fn r#set_ip_type_of_service(&self, mut value: u8) -> Self::SetIpTypeOfServiceResponseFut {
5165        fn _decode(
5166            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5167        ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error>
5168        {
5169            let _response = fidl::client::decode_transaction_body::<
5170                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
5171                fidl::encoding::DefaultFuchsiaResourceDialect,
5172                0x995c600475b6d46,
5173            >(_buf?)?;
5174            Ok(_response.map(|x| x))
5175        }
5176        self.client.send_query_and_decode::<
5177            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTypeOfServiceRequest,
5178            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTypeOfServiceResult,
5179        >(
5180            (value,),
5181            0x995c600475b6d46,
5182            fidl::encoding::DynamicFlags::empty(),
5183            _decode,
5184        )
5185    }
5186
5187    type GetIpTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
5188        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTypeOfServiceResult,
5189        fidl::encoding::DefaultFuchsiaResourceDialect,
5190    >;
5191    fn r#get_ip_type_of_service(&self) -> Self::GetIpTypeOfServiceResponseFut {
5192        fn _decode(
5193            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5194        ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error>
5195        {
5196            let _response = fidl::client::decode_transaction_body::<
5197                fidl::encoding::ResultType<
5198                    fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTypeOfServiceResponse,
5199                    fidl_fuchsia_posix::Errno,
5200                >,
5201                fidl::encoding::DefaultFuchsiaResourceDialect,
5202                0x3814a04259f75fcb,
5203            >(_buf?)?;
5204            Ok(_response.map(|x| x.value))
5205        }
5206        self.client.send_query_and_decode::<
5207            fidl::encoding::EmptyPayload,
5208            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTypeOfServiceResult,
5209        >(
5210            (),
5211            0x3814a04259f75fcb,
5212            fidl::encoding::DynamicFlags::empty(),
5213            _decode,
5214        )
5215    }
5216
5217    type SetIpTtlResponseFut = fidl::client::QueryResponseFut<
5218        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTtlResult,
5219        fidl::encoding::DefaultFuchsiaResourceDialect,
5220    >;
5221    fn r#set_ip_ttl(
5222        &self,
5223        mut value: &fidl_fuchsia_posix_socket::OptionalUint8,
5224    ) -> Self::SetIpTtlResponseFut {
5225        fn _decode(
5226            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5227        ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTtlResult, fidl::Error>
5228        {
5229            let _response = fidl::client::decode_transaction_body::<
5230                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
5231                fidl::encoding::DefaultFuchsiaResourceDialect,
5232                0x29e2424b433ae1ef,
5233            >(_buf?)?;
5234            Ok(_response.map(|x| x))
5235        }
5236        self.client.send_query_and_decode::<
5237            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTtlRequest,
5238            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTtlResult,
5239        >(
5240            (value,),
5241            0x29e2424b433ae1ef,
5242            fidl::encoding::DynamicFlags::empty(),
5243            _decode,
5244        )
5245    }
5246
5247    type GetIpTtlResponseFut = fidl::client::QueryResponseFut<
5248        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTtlResult,
5249        fidl::encoding::DefaultFuchsiaResourceDialect,
5250    >;
5251    fn r#get_ip_ttl(&self) -> Self::GetIpTtlResponseFut {
5252        fn _decode(
5253            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5254        ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTtlResult, fidl::Error>
5255        {
5256            let _response = fidl::client::decode_transaction_body::<
5257                fidl::encoding::ResultType<
5258                    fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTtlResponse,
5259                    fidl_fuchsia_posix::Errno,
5260                >,
5261                fidl::encoding::DefaultFuchsiaResourceDialect,
5262                0x47e47fa1f24da471,
5263            >(_buf?)?;
5264            Ok(_response.map(|x| x.value))
5265        }
5266        self.client.send_query_and_decode::<
5267            fidl::encoding::EmptyPayload,
5268            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTtlResult,
5269        >(
5270            (),
5271            0x47e47fa1f24da471,
5272            fidl::encoding::DynamicFlags::empty(),
5273            _decode,
5274        )
5275    }
5276
5277    type SetIpPacketInfoResponseFut = fidl::client::QueryResponseFut<
5278        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpPacketInfoResult,
5279        fidl::encoding::DefaultFuchsiaResourceDialect,
5280    >;
5281    fn r#set_ip_packet_info(&self, mut value: bool) -> Self::SetIpPacketInfoResponseFut {
5282        fn _decode(
5283            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5284        ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpPacketInfoResult, fidl::Error>
5285        {
5286            let _response = fidl::client::decode_transaction_body::<
5287                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
5288                fidl::encoding::DefaultFuchsiaResourceDialect,
5289                0x392d16bee20c0e16,
5290            >(_buf?)?;
5291            Ok(_response.map(|x| x))
5292        }
5293        self.client.send_query_and_decode::<
5294            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpPacketInfoRequest,
5295            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpPacketInfoResult,
5296        >(
5297            (value,),
5298            0x392d16bee20c0e16,
5299            fidl::encoding::DynamicFlags::empty(),
5300            _decode,
5301        )
5302    }
5303
5304    type GetIpPacketInfoResponseFut = fidl::client::QueryResponseFut<
5305        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpPacketInfoResult,
5306        fidl::encoding::DefaultFuchsiaResourceDialect,
5307    >;
5308    fn r#get_ip_packet_info(&self) -> Self::GetIpPacketInfoResponseFut {
5309        fn _decode(
5310            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5311        ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpPacketInfoResult, fidl::Error>
5312        {
5313            let _response = fidl::client::decode_transaction_body::<
5314                fidl::encoding::ResultType<
5315                    fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpPacketInfoResponse,
5316                    fidl_fuchsia_posix::Errno,
5317                >,
5318                fidl::encoding::DefaultFuchsiaResourceDialect,
5319                0x54b505f242280740,
5320            >(_buf?)?;
5321            Ok(_response.map(|x| x.value))
5322        }
5323        self.client.send_query_and_decode::<
5324            fidl::encoding::EmptyPayload,
5325            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpPacketInfoResult,
5326        >(
5327            (),
5328            0x54b505f242280740,
5329            fidl::encoding::DynamicFlags::empty(),
5330            _decode,
5331        )
5332    }
5333
5334    type SetIpReceiveTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
5335        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
5336        fidl::encoding::DefaultFuchsiaResourceDialect,
5337    >;
5338    fn r#set_ip_receive_type_of_service(
5339        &self,
5340        mut value: bool,
5341    ) -> Self::SetIpReceiveTypeOfServiceResponseFut {
5342        fn _decode(
5343            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5344        ) -> Result<
5345            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
5346            fidl::Error,
5347        > {
5348            let _response = fidl::client::decode_transaction_body::<
5349                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
5350                fidl::encoding::DefaultFuchsiaResourceDialect,
5351                0x6c4f6714995f84ef,
5352            >(_buf?)?;
5353            Ok(_response.map(|x| x))
5354        }
5355        self.client.send_query_and_decode::<
5356            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveTypeOfServiceRequest,
5357            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
5358        >(
5359            (value,),
5360            0x6c4f6714995f84ef,
5361            fidl::encoding::DynamicFlags::empty(),
5362            _decode,
5363        )
5364    }
5365
5366    type GetIpReceiveTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
5367        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
5368        fidl::encoding::DefaultFuchsiaResourceDialect,
5369    >;
5370    fn r#get_ip_receive_type_of_service(&self) -> Self::GetIpReceiveTypeOfServiceResponseFut {
5371        fn _decode(
5372            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5373        ) -> Result<
5374            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
5375            fidl::Error,
5376        > {
5377            let _response = fidl::client::decode_transaction_body::<
5378                fidl::encoding::ResultType<
5379                    fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
5380                    fidl_fuchsia_posix::Errno,
5381                >,
5382                fidl::encoding::DefaultFuchsiaResourceDialect,
5383                0x4158ba7dc2795960,
5384            >(_buf?)?;
5385            Ok(_response.map(|x| x.value))
5386        }
5387        self.client.send_query_and_decode::<
5388            fidl::encoding::EmptyPayload,
5389            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
5390        >(
5391            (),
5392            0x4158ba7dc2795960,
5393            fidl::encoding::DynamicFlags::empty(),
5394            _decode,
5395        )
5396    }
5397
5398    type SetIpReceiveTtlResponseFut = fidl::client::QueryResponseFut<
5399        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveTtlResult,
5400        fidl::encoding::DefaultFuchsiaResourceDialect,
5401    >;
5402    fn r#set_ip_receive_ttl(&self, mut value: bool) -> Self::SetIpReceiveTtlResponseFut {
5403        fn _decode(
5404            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5405        ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error>
5406        {
5407            let _response = fidl::client::decode_transaction_body::<
5408                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
5409                fidl::encoding::DefaultFuchsiaResourceDialect,
5410                0x46f15be0ce0ab82b,
5411            >(_buf?)?;
5412            Ok(_response.map(|x| x))
5413        }
5414        self.client.send_query_and_decode::<
5415            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveTtlRequest,
5416            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveTtlResult,
5417        >(
5418            (value,),
5419            0x46f15be0ce0ab82b,
5420            fidl::encoding::DynamicFlags::empty(),
5421            _decode,
5422        )
5423    }
5424
5425    type GetIpReceiveTtlResponseFut = fidl::client::QueryResponseFut<
5426        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveTtlResult,
5427        fidl::encoding::DefaultFuchsiaResourceDialect,
5428    >;
5429    fn r#get_ip_receive_ttl(&self) -> Self::GetIpReceiveTtlResponseFut {
5430        fn _decode(
5431            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5432        ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error>
5433        {
5434            let _response = fidl::client::decode_transaction_body::<
5435                fidl::encoding::ResultType<
5436                    fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveTtlResponse,
5437                    fidl_fuchsia_posix::Errno,
5438                >,
5439                fidl::encoding::DefaultFuchsiaResourceDialect,
5440                0x678ddd5a5dfa2eb5,
5441            >(_buf?)?;
5442            Ok(_response.map(|x| x.value))
5443        }
5444        self.client.send_query_and_decode::<
5445            fidl::encoding::EmptyPayload,
5446            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveTtlResult,
5447        >(
5448            (),
5449            0x678ddd5a5dfa2eb5,
5450            fidl::encoding::DynamicFlags::empty(),
5451            _decode,
5452        )
5453    }
5454
5455    type SetIpMulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
5456        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastInterfaceResult,
5457        fidl::encoding::DefaultFuchsiaResourceDialect,
5458    >;
5459    fn r#set_ip_multicast_interface(
5460        &self,
5461        mut iface: u64,
5462        mut address: &fidl_fuchsia_net::Ipv4Address,
5463    ) -> Self::SetIpMulticastInterfaceResponseFut {
5464        fn _decode(
5465            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5466        ) -> Result<
5467            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastInterfaceResult,
5468            fidl::Error,
5469        > {
5470            let _response = fidl::client::decode_transaction_body::<
5471                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
5472                fidl::encoding::DefaultFuchsiaResourceDialect,
5473                0x752fbfa9b12befe,
5474            >(_buf?)?;
5475            Ok(_response.map(|x| x))
5476        }
5477        self.client.send_query_and_decode::<
5478            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastInterfaceRequest,
5479            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastInterfaceResult,
5480        >(
5481            (iface, address,),
5482            0x752fbfa9b12befe,
5483            fidl::encoding::DynamicFlags::empty(),
5484            _decode,
5485        )
5486    }
5487
5488    type GetIpMulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
5489        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastInterfaceResult,
5490        fidl::encoding::DefaultFuchsiaResourceDialect,
5491    >;
5492    fn r#get_ip_multicast_interface(&self) -> Self::GetIpMulticastInterfaceResponseFut {
5493        fn _decode(
5494            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5495        ) -> Result<
5496            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastInterfaceResult,
5497            fidl::Error,
5498        > {
5499            let _response = fidl::client::decode_transaction_body::<
5500                fidl::encoding::ResultType<
5501                    fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastInterfaceResponse,
5502                    fidl_fuchsia_posix::Errno,
5503                >,
5504                fidl::encoding::DefaultFuchsiaResourceDialect,
5505                0x320bd14c4df046c4,
5506            >(_buf?)?;
5507            Ok(_response.map(|x| x.value))
5508        }
5509        self.client.send_query_and_decode::<
5510            fidl::encoding::EmptyPayload,
5511            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastInterfaceResult,
5512        >(
5513            (),
5514            0x320bd14c4df046c4,
5515            fidl::encoding::DynamicFlags::empty(),
5516            _decode,
5517        )
5518    }
5519
5520    type SetIpMulticastTtlResponseFut = fidl::client::QueryResponseFut<
5521        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastTtlResult,
5522        fidl::encoding::DefaultFuchsiaResourceDialect,
5523    >;
5524    fn r#set_ip_multicast_ttl(
5525        &self,
5526        mut value: &fidl_fuchsia_posix_socket::OptionalUint8,
5527    ) -> Self::SetIpMulticastTtlResponseFut {
5528        fn _decode(
5529            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5530        ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error>
5531        {
5532            let _response = fidl::client::decode_transaction_body::<
5533                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
5534                fidl::encoding::DefaultFuchsiaResourceDialect,
5535                0x63134d53772916a1,
5536            >(_buf?)?;
5537            Ok(_response.map(|x| x))
5538        }
5539        self.client.send_query_and_decode::<
5540            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastTtlRequest,
5541            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastTtlResult,
5542        >(
5543            (value,),
5544            0x63134d53772916a1,
5545            fidl::encoding::DynamicFlags::empty(),
5546            _decode,
5547        )
5548    }
5549
5550    type GetIpMulticastTtlResponseFut = fidl::client::QueryResponseFut<
5551        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastTtlResult,
5552        fidl::encoding::DefaultFuchsiaResourceDialect,
5553    >;
5554    fn r#get_ip_multicast_ttl(&self) -> Self::GetIpMulticastTtlResponseFut {
5555        fn _decode(
5556            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5557        ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error>
5558        {
5559            let _response = fidl::client::decode_transaction_body::<
5560                fidl::encoding::ResultType<
5561                    fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastTtlResponse,
5562                    fidl_fuchsia_posix::Errno,
5563                >,
5564                fidl::encoding::DefaultFuchsiaResourceDialect,
5565                0x4665cd378f39e1a,
5566            >(_buf?)?;
5567            Ok(_response.map(|x| x.value))
5568        }
5569        self.client.send_query_and_decode::<
5570            fidl::encoding::EmptyPayload,
5571            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastTtlResult,
5572        >(
5573            (),
5574            0x4665cd378f39e1a,
5575            fidl::encoding::DynamicFlags::empty(),
5576            _decode,
5577        )
5578    }
5579
5580    type SetIpMulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
5581        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastLoopbackResult,
5582        fidl::encoding::DefaultFuchsiaResourceDialect,
5583    >;
5584    fn r#set_ip_multicast_loopback(
5585        &self,
5586        mut value: bool,
5587    ) -> Self::SetIpMulticastLoopbackResponseFut {
5588        fn _decode(
5589            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5590        ) -> Result<
5591            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastLoopbackResult,
5592            fidl::Error,
5593        > {
5594            let _response = fidl::client::decode_transaction_body::<
5595                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
5596                fidl::encoding::DefaultFuchsiaResourceDialect,
5597                0x20c55c11f00943ea,
5598            >(_buf?)?;
5599            Ok(_response.map(|x| x))
5600        }
5601        self.client.send_query_and_decode::<
5602            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastLoopbackRequest,
5603            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastLoopbackResult,
5604        >(
5605            (value,),
5606            0x20c55c11f00943ea,
5607            fidl::encoding::DynamicFlags::empty(),
5608            _decode,
5609        )
5610    }
5611
5612    type GetIpMulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
5613        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastLoopbackResult,
5614        fidl::encoding::DefaultFuchsiaResourceDialect,
5615    >;
5616    fn r#get_ip_multicast_loopback(&self) -> Self::GetIpMulticastLoopbackResponseFut {
5617        fn _decode(
5618            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5619        ) -> Result<
5620            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastLoopbackResult,
5621            fidl::Error,
5622        > {
5623            let _response = fidl::client::decode_transaction_body::<
5624                fidl::encoding::ResultType<
5625                    fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastLoopbackResponse,
5626                    fidl_fuchsia_posix::Errno,
5627                >,
5628                fidl::encoding::DefaultFuchsiaResourceDialect,
5629                0x3b6b26ff558298f2,
5630            >(_buf?)?;
5631            Ok(_response.map(|x| x.value))
5632        }
5633        self.client.send_query_and_decode::<
5634            fidl::encoding::EmptyPayload,
5635            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastLoopbackResult,
5636        >(
5637            (),
5638            0x3b6b26ff558298f2,
5639            fidl::encoding::DynamicFlags::empty(),
5640            _decode,
5641        )
5642    }
5643
5644    type AddIpMembershipResponseFut = fidl::client::QueryResponseFut<
5645        fidl_fuchsia_posix_socket::BaseNetworkSocketAddIpMembershipResult,
5646        fidl::encoding::DefaultFuchsiaResourceDialect,
5647    >;
5648    fn r#add_ip_membership(
5649        &self,
5650        mut membership: &fidl_fuchsia_posix_socket::IpMulticastMembership,
5651    ) -> Self::AddIpMembershipResponseFut {
5652        fn _decode(
5653            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5654        ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketAddIpMembershipResult, fidl::Error>
5655        {
5656            let _response = fidl::client::decode_transaction_body::<
5657                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
5658                fidl::encoding::DefaultFuchsiaResourceDialect,
5659                0x76bc7df115a3b4d0,
5660            >(_buf?)?;
5661            Ok(_response.map(|x| x))
5662        }
5663        self.client.send_query_and_decode::<
5664            fidl_fuchsia_posix_socket::BaseNetworkSocketAddIpMembershipRequest,
5665            fidl_fuchsia_posix_socket::BaseNetworkSocketAddIpMembershipResult,
5666        >(
5667            (membership,),
5668            0x76bc7df115a3b4d0,
5669            fidl::encoding::DynamicFlags::empty(),
5670            _decode,
5671        )
5672    }
5673
5674    type DropIpMembershipResponseFut = fidl::client::QueryResponseFut<
5675        fidl_fuchsia_posix_socket::BaseNetworkSocketDropIpMembershipResult,
5676        fidl::encoding::DefaultFuchsiaResourceDialect,
5677    >;
5678    fn r#drop_ip_membership(
5679        &self,
5680        mut membership: &fidl_fuchsia_posix_socket::IpMulticastMembership,
5681    ) -> Self::DropIpMembershipResponseFut {
5682        fn _decode(
5683            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5684        ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketDropIpMembershipResult, fidl::Error>
5685        {
5686            let _response = fidl::client::decode_transaction_body::<
5687                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
5688                fidl::encoding::DefaultFuchsiaResourceDialect,
5689                0x2888f3099188d03,
5690            >(_buf?)?;
5691            Ok(_response.map(|x| x))
5692        }
5693        self.client.send_query_and_decode::<
5694            fidl_fuchsia_posix_socket::BaseNetworkSocketDropIpMembershipRequest,
5695            fidl_fuchsia_posix_socket::BaseNetworkSocketDropIpMembershipResult,
5696        >(
5697            (membership,),
5698            0x2888f3099188d03,
5699            fidl::encoding::DynamicFlags::empty(),
5700            _decode,
5701        )
5702    }
5703
5704    type SetIpTransparentResponseFut = fidl::client::QueryResponseFut<
5705        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTransparentResult,
5706        fidl::encoding::DefaultFuchsiaResourceDialect,
5707    >;
5708    fn r#set_ip_transparent(&self, mut value: bool) -> Self::SetIpTransparentResponseFut {
5709        fn _decode(
5710            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5711        ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTransparentResult, fidl::Error>
5712        {
5713            let _response = fidl::client::decode_transaction_body::<
5714                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
5715                fidl::encoding::DefaultFuchsiaResourceDialect,
5716                0x1ae532b0c066e3a0,
5717            >(_buf?)?;
5718            Ok(_response.map(|x| x))
5719        }
5720        self.client.send_query_and_decode::<
5721            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTransparentRequest,
5722            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTransparentResult,
5723        >(
5724            (value,),
5725            0x1ae532b0c066e3a0,
5726            fidl::encoding::DynamicFlags::empty(),
5727            _decode,
5728        )
5729    }
5730
5731    type GetIpTransparentResponseFut = fidl::client::QueryResponseFut<
5732        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTransparentResult,
5733        fidl::encoding::DefaultFuchsiaResourceDialect,
5734    >;
5735    fn r#get_ip_transparent(&self) -> Self::GetIpTransparentResponseFut {
5736        fn _decode(
5737            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5738        ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTransparentResult, fidl::Error>
5739        {
5740            let _response = fidl::client::decode_transaction_body::<
5741                fidl::encoding::ResultType<
5742                    fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTransparentResponse,
5743                    fidl_fuchsia_posix::Errno,
5744                >,
5745                fidl::encoding::DefaultFuchsiaResourceDialect,
5746                0x51d43695962ebfb5,
5747            >(_buf?)?;
5748            Ok(_response.map(|x| x.value))
5749        }
5750        self.client.send_query_and_decode::<
5751            fidl::encoding::EmptyPayload,
5752            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTransparentResult,
5753        >(
5754            (),
5755            0x51d43695962ebfb5,
5756            fidl::encoding::DynamicFlags::empty(),
5757            _decode,
5758        )
5759    }
5760
5761    type SetIpReceiveOriginalDestinationAddressResponseFut = fidl::client::QueryResponseFut<
5762        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
5763        fidl::encoding::DefaultFuchsiaResourceDialect,
5764    >;
5765    fn r#set_ip_receive_original_destination_address(
5766        &self,
5767        mut value: bool,
5768    ) -> Self::SetIpReceiveOriginalDestinationAddressResponseFut {
5769        fn _decode(mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, fidl::Error>{
5770            let _response = fidl::client::decode_transaction_body::<
5771                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
5772                fidl::encoding::DefaultFuchsiaResourceDialect,
5773                0x4722b4ce52f7840,
5774            >(_buf?)?;
5775            Ok(_response.map(|x| x))
5776        }
5777        self.client.send_query_and_decode::<
5778            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest,
5779            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
5780        >(
5781            (value,),
5782            0x4722b4ce52f7840,
5783            fidl::encoding::DynamicFlags::empty(),
5784            _decode,
5785        )
5786    }
5787
5788    type GetIpReceiveOriginalDestinationAddressResponseFut = fidl::client::QueryResponseFut<
5789        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
5790        fidl::encoding::DefaultFuchsiaResourceDialect,
5791    >;
5792    fn r#get_ip_receive_original_destination_address(
5793        &self,
5794    ) -> Self::GetIpReceiveOriginalDestinationAddressResponseFut {
5795        fn _decode(mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, fidl::Error>{
5796            let _response = fidl::client::decode_transaction_body::<fidl::encoding::ResultType<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse, fidl_fuchsia_posix::Errno>, fidl::encoding::DefaultFuchsiaResourceDialect, 0x2a0e7dc5d6bfdfe9>(_buf?)?;
5797            Ok(_response.map(|x| x.value))
5798        }
5799        self.client.send_query_and_decode::<
5800            fidl::encoding::EmptyPayload,
5801            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
5802        >(
5803            (),
5804            0x2a0e7dc5d6bfdfe9,
5805            fidl::encoding::DynamicFlags::empty(),
5806            _decode,
5807        )
5808    }
5809
5810    type AddIpv6MembershipResponseFut = fidl::client::QueryResponseFut<
5811        fidl_fuchsia_posix_socket::BaseNetworkSocketAddIpv6MembershipResult,
5812        fidl::encoding::DefaultFuchsiaResourceDialect,
5813    >;
5814    fn r#add_ipv6_membership(
5815        &self,
5816        mut membership: &fidl_fuchsia_posix_socket::Ipv6MulticastMembership,
5817    ) -> Self::AddIpv6MembershipResponseFut {
5818        fn _decode(
5819            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5820        ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketAddIpv6MembershipResult, fidl::Error>
5821        {
5822            let _response = fidl::client::decode_transaction_body::<
5823                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
5824                fidl::encoding::DefaultFuchsiaResourceDialect,
5825                0x7c94727acb4ea4b3,
5826            >(_buf?)?;
5827            Ok(_response.map(|x| x))
5828        }
5829        self.client.send_query_and_decode::<
5830            fidl_fuchsia_posix_socket::BaseNetworkSocketAddIpv6MembershipRequest,
5831            fidl_fuchsia_posix_socket::BaseNetworkSocketAddIpv6MembershipResult,
5832        >(
5833            (membership,),
5834            0x7c94727acb4ea4b3,
5835            fidl::encoding::DynamicFlags::empty(),
5836            _decode,
5837        )
5838    }
5839
5840    type DropIpv6MembershipResponseFut = fidl::client::QueryResponseFut<
5841        fidl_fuchsia_posix_socket::BaseNetworkSocketDropIpv6MembershipResult,
5842        fidl::encoding::DefaultFuchsiaResourceDialect,
5843    >;
5844    fn r#drop_ipv6_membership(
5845        &self,
5846        mut membership: &fidl_fuchsia_posix_socket::Ipv6MulticastMembership,
5847    ) -> Self::DropIpv6MembershipResponseFut {
5848        fn _decode(
5849            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5850        ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketDropIpv6MembershipResult, fidl::Error>
5851        {
5852            let _response = fidl::client::decode_transaction_body::<
5853                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
5854                fidl::encoding::DefaultFuchsiaResourceDialect,
5855                0x42104c70ccaba304,
5856            >(_buf?)?;
5857            Ok(_response.map(|x| x))
5858        }
5859        self.client.send_query_and_decode::<
5860            fidl_fuchsia_posix_socket::BaseNetworkSocketDropIpv6MembershipRequest,
5861            fidl_fuchsia_posix_socket::BaseNetworkSocketDropIpv6MembershipResult,
5862        >(
5863            (membership,),
5864            0x42104c70ccaba304,
5865            fidl::encoding::DynamicFlags::empty(),
5866            _decode,
5867        )
5868    }
5869
5870    type SetIpv6MulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
5871        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastInterfaceResult,
5872        fidl::encoding::DefaultFuchsiaResourceDialect,
5873    >;
5874    fn r#set_ipv6_multicast_interface(
5875        &self,
5876        mut value: u64,
5877    ) -> Self::SetIpv6MulticastInterfaceResponseFut {
5878        fn _decode(
5879            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5880        ) -> Result<
5881            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastInterfaceResult,
5882            fidl::Error,
5883        > {
5884            let _response = fidl::client::decode_transaction_body::<
5885                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
5886                fidl::encoding::DefaultFuchsiaResourceDialect,
5887                0x135f76db3774ab3b,
5888            >(_buf?)?;
5889            Ok(_response.map(|x| x))
5890        }
5891        self.client.send_query_and_decode::<
5892            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastInterfaceRequest,
5893            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastInterfaceResult,
5894        >(
5895            (value,),
5896            0x135f76db3774ab3b,
5897            fidl::encoding::DynamicFlags::empty(),
5898            _decode,
5899        )
5900    }
5901
5902    type GetIpv6MulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
5903        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastInterfaceResult,
5904        fidl::encoding::DefaultFuchsiaResourceDialect,
5905    >;
5906    fn r#get_ipv6_multicast_interface(&self) -> Self::GetIpv6MulticastInterfaceResponseFut {
5907        fn _decode(
5908            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5909        ) -> Result<
5910            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastInterfaceResult,
5911            fidl::Error,
5912        > {
5913            let _response = fidl::client::decode_transaction_body::<
5914                fidl::encoding::ResultType<
5915                    fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
5916                    fidl_fuchsia_posix::Errno,
5917                >,
5918                fidl::encoding::DefaultFuchsiaResourceDialect,
5919                0x1f26fcdd348f1882,
5920            >(_buf?)?;
5921            Ok(_response.map(|x| x.value))
5922        }
5923        self.client.send_query_and_decode::<
5924            fidl::encoding::EmptyPayload,
5925            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastInterfaceResult,
5926        >(
5927            (),
5928            0x1f26fcdd348f1882,
5929            fidl::encoding::DynamicFlags::empty(),
5930            _decode,
5931        )
5932    }
5933
5934    type SetIpv6UnicastHopsResponseFut = fidl::client::QueryResponseFut<
5935        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6UnicastHopsResult,
5936        fidl::encoding::DefaultFuchsiaResourceDialect,
5937    >;
5938    fn r#set_ipv6_unicast_hops(
5939        &self,
5940        mut value: &fidl_fuchsia_posix_socket::OptionalUint8,
5941    ) -> Self::SetIpv6UnicastHopsResponseFut {
5942        fn _decode(
5943            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5944        ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error>
5945        {
5946            let _response = fidl::client::decode_transaction_body::<
5947                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
5948                fidl::encoding::DefaultFuchsiaResourceDialect,
5949                0x157d51e98f462859,
5950            >(_buf?)?;
5951            Ok(_response.map(|x| x))
5952        }
5953        self.client.send_query_and_decode::<
5954            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6UnicastHopsRequest,
5955            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6UnicastHopsResult,
5956        >(
5957            (value,),
5958            0x157d51e98f462859,
5959            fidl::encoding::DynamicFlags::empty(),
5960            _decode,
5961        )
5962    }
5963
5964    type GetIpv6UnicastHopsResponseFut = fidl::client::QueryResponseFut<
5965        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6UnicastHopsResult,
5966        fidl::encoding::DefaultFuchsiaResourceDialect,
5967    >;
5968    fn r#get_ipv6_unicast_hops(&self) -> Self::GetIpv6UnicastHopsResponseFut {
5969        fn _decode(
5970            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5971        ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error>
5972        {
5973            let _response = fidl::client::decode_transaction_body::<
5974                fidl::encoding::ResultType<
5975                    fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6UnicastHopsResponse,
5976                    fidl_fuchsia_posix::Errno,
5977                >,
5978                fidl::encoding::DefaultFuchsiaResourceDialect,
5979                0x21f4641cad8bd8d2,
5980            >(_buf?)?;
5981            Ok(_response.map(|x| x.value))
5982        }
5983        self.client.send_query_and_decode::<
5984            fidl::encoding::EmptyPayload,
5985            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6UnicastHopsResult,
5986        >(
5987            (),
5988            0x21f4641cad8bd8d2,
5989            fidl::encoding::DynamicFlags::empty(),
5990            _decode,
5991        )
5992    }
5993
5994    type SetIpv6ReceiveHopLimitResponseFut = fidl::client::QueryResponseFut<
5995        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
5996        fidl::encoding::DefaultFuchsiaResourceDialect,
5997    >;
5998    fn r#set_ipv6_receive_hop_limit(
5999        &self,
6000        mut value: bool,
6001    ) -> Self::SetIpv6ReceiveHopLimitResponseFut {
6002        fn _decode(
6003            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6004        ) -> Result<
6005            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
6006            fidl::Error,
6007        > {
6008            let _response = fidl::client::decode_transaction_body::<
6009                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
6010                fidl::encoding::DefaultFuchsiaResourceDialect,
6011                0x5c24808ed2e84a1e,
6012            >(_buf?)?;
6013            Ok(_response.map(|x| x))
6014        }
6015        self.client.send_query_and_decode::<
6016            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceiveHopLimitRequest,
6017            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
6018        >(
6019            (value,),
6020            0x5c24808ed2e84a1e,
6021            fidl::encoding::DynamicFlags::empty(),
6022            _decode,
6023        )
6024    }
6025
6026    type GetIpv6ReceiveHopLimitResponseFut = fidl::client::QueryResponseFut<
6027        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
6028        fidl::encoding::DefaultFuchsiaResourceDialect,
6029    >;
6030    fn r#get_ipv6_receive_hop_limit(&self) -> Self::GetIpv6ReceiveHopLimitResponseFut {
6031        fn _decode(
6032            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6033        ) -> Result<
6034            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
6035            fidl::Error,
6036        > {
6037            let _response = fidl::client::decode_transaction_body::<
6038                fidl::encoding::ResultType<
6039                    fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
6040                    fidl_fuchsia_posix::Errno,
6041                >,
6042                fidl::encoding::DefaultFuchsiaResourceDialect,
6043                0x341e06689885b4c0,
6044            >(_buf?)?;
6045            Ok(_response.map(|x| x.value))
6046        }
6047        self.client.send_query_and_decode::<
6048            fidl::encoding::EmptyPayload,
6049            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
6050        >(
6051            (),
6052            0x341e06689885b4c0,
6053            fidl::encoding::DynamicFlags::empty(),
6054            _decode,
6055        )
6056    }
6057
6058    type SetIpv6MulticastHopsResponseFut = fidl::client::QueryResponseFut<
6059        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastHopsResult,
6060        fidl::encoding::DefaultFuchsiaResourceDialect,
6061    >;
6062    fn r#set_ipv6_multicast_hops(
6063        &self,
6064        mut value: &fidl_fuchsia_posix_socket::OptionalUint8,
6065    ) -> Self::SetIpv6MulticastHopsResponseFut {
6066        fn _decode(
6067            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6068        ) -> Result<
6069            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastHopsResult,
6070            fidl::Error,
6071        > {
6072            let _response = fidl::client::decode_transaction_body::<
6073                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
6074                fidl::encoding::DefaultFuchsiaResourceDialect,
6075                0x25b9cd4d181f82c1,
6076            >(_buf?)?;
6077            Ok(_response.map(|x| x))
6078        }
6079        self.client.send_query_and_decode::<
6080            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastHopsRequest,
6081            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastHopsResult,
6082        >(
6083            (value,),
6084            0x25b9cd4d181f82c1,
6085            fidl::encoding::DynamicFlags::empty(),
6086            _decode,
6087        )
6088    }
6089
6090    type GetIpv6MulticastHopsResponseFut = fidl::client::QueryResponseFut<
6091        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastHopsResult,
6092        fidl::encoding::DefaultFuchsiaResourceDialect,
6093    >;
6094    fn r#get_ipv6_multicast_hops(&self) -> Self::GetIpv6MulticastHopsResponseFut {
6095        fn _decode(
6096            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6097        ) -> Result<
6098            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastHopsResult,
6099            fidl::Error,
6100        > {
6101            let _response = fidl::client::decode_transaction_body::<
6102                fidl::encoding::ResultType<
6103                    fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastHopsResponse,
6104                    fidl_fuchsia_posix::Errno,
6105                >,
6106                fidl::encoding::DefaultFuchsiaResourceDialect,
6107                0x52916948a365012a,
6108            >(_buf?)?;
6109            Ok(_response.map(|x| x.value))
6110        }
6111        self.client.send_query_and_decode::<
6112            fidl::encoding::EmptyPayload,
6113            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastHopsResult,
6114        >(
6115            (),
6116            0x52916948a365012a,
6117            fidl::encoding::DynamicFlags::empty(),
6118            _decode,
6119        )
6120    }
6121
6122    type SetIpv6MulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
6123        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastLoopbackResult,
6124        fidl::encoding::DefaultFuchsiaResourceDialect,
6125    >;
6126    fn r#set_ipv6_multicast_loopback(
6127        &self,
6128        mut value: bool,
6129    ) -> Self::SetIpv6MulticastLoopbackResponseFut {
6130        fn _decode(
6131            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6132        ) -> Result<
6133            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastLoopbackResult,
6134            fidl::Error,
6135        > {
6136            let _response = fidl::client::decode_transaction_body::<
6137                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
6138                fidl::encoding::DefaultFuchsiaResourceDialect,
6139                0x55701c409ff41b40,
6140            >(_buf?)?;
6141            Ok(_response.map(|x| x))
6142        }
6143        self.client.send_query_and_decode::<
6144            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastLoopbackRequest,
6145            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastLoopbackResult,
6146        >(
6147            (value,),
6148            0x55701c409ff41b40,
6149            fidl::encoding::DynamicFlags::empty(),
6150            _decode,
6151        )
6152    }
6153
6154    type GetIpv6MulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
6155        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastLoopbackResult,
6156        fidl::encoding::DefaultFuchsiaResourceDialect,
6157    >;
6158    fn r#get_ipv6_multicast_loopback(&self) -> Self::GetIpv6MulticastLoopbackResponseFut {
6159        fn _decode(
6160            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6161        ) -> Result<
6162            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastLoopbackResult,
6163            fidl::Error,
6164        > {
6165            let _response = fidl::client::decode_transaction_body::<
6166                fidl::encoding::ResultType<
6167                    fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
6168                    fidl_fuchsia_posix::Errno,
6169                >,
6170                fidl::encoding::DefaultFuchsiaResourceDialect,
6171                0x4415b701fde319c3,
6172            >(_buf?)?;
6173            Ok(_response.map(|x| x.value))
6174        }
6175        self.client.send_query_and_decode::<
6176            fidl::encoding::EmptyPayload,
6177            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastLoopbackResult,
6178        >(
6179            (),
6180            0x4415b701fde319c3,
6181            fidl::encoding::DynamicFlags::empty(),
6182            _decode,
6183        )
6184    }
6185
6186    type SetIpv6OnlyResponseFut = fidl::client::QueryResponseFut<
6187        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6OnlyResult,
6188        fidl::encoding::DefaultFuchsiaResourceDialect,
6189    >;
6190    fn r#set_ipv6_only(&self, mut value: bool) -> Self::SetIpv6OnlyResponseFut {
6191        fn _decode(
6192            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6193        ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6OnlyResult, fidl::Error>
6194        {
6195            let _response = fidl::client::decode_transaction_body::<
6196                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
6197                fidl::encoding::DefaultFuchsiaResourceDialect,
6198                0x4873f1364758cbba,
6199            >(_buf?)?;
6200            Ok(_response.map(|x| x))
6201        }
6202        self.client.send_query_and_decode::<
6203            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6OnlyRequest,
6204            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6OnlyResult,
6205        >(
6206            (value,),
6207            0x4873f1364758cbba,
6208            fidl::encoding::DynamicFlags::empty(),
6209            _decode,
6210        )
6211    }
6212
6213    type GetIpv6OnlyResponseFut = fidl::client::QueryResponseFut<
6214        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6OnlyResult,
6215        fidl::encoding::DefaultFuchsiaResourceDialect,
6216    >;
6217    fn r#get_ipv6_only(&self) -> Self::GetIpv6OnlyResponseFut {
6218        fn _decode(
6219            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6220        ) -> Result<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6OnlyResult, fidl::Error>
6221        {
6222            let _response = fidl::client::decode_transaction_body::<
6223                fidl::encoding::ResultType<
6224                    fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6OnlyResponse,
6225                    fidl_fuchsia_posix::Errno,
6226                >,
6227                fidl::encoding::DefaultFuchsiaResourceDialect,
6228                0x4aa3340a1a26b89c,
6229            >(_buf?)?;
6230            Ok(_response.map(|x| x.value))
6231        }
6232        self.client.send_query_and_decode::<
6233            fidl::encoding::EmptyPayload,
6234            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6OnlyResult,
6235        >(
6236            (),
6237            0x4aa3340a1a26b89c,
6238            fidl::encoding::DynamicFlags::empty(),
6239            _decode,
6240        )
6241    }
6242
6243    type SetIpv6ReceiveTrafficClassResponseFut = fidl::client::QueryResponseFut<
6244        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
6245        fidl::encoding::DefaultFuchsiaResourceDialect,
6246    >;
6247    fn r#set_ipv6_receive_traffic_class(
6248        &self,
6249        mut value: bool,
6250    ) -> Self::SetIpv6ReceiveTrafficClassResponseFut {
6251        fn _decode(
6252            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6253        ) -> Result<
6254            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
6255            fidl::Error,
6256        > {
6257            let _response = fidl::client::decode_transaction_body::<
6258                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
6259                fidl::encoding::DefaultFuchsiaResourceDialect,
6260                0x58f07c8788d099a0,
6261            >(_buf?)?;
6262            Ok(_response.map(|x| x))
6263        }
6264        self.client.send_query_and_decode::<
6265            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest,
6266            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
6267        >(
6268            (value,),
6269            0x58f07c8788d099a0,
6270            fidl::encoding::DynamicFlags::empty(),
6271            _decode,
6272        )
6273    }
6274
6275    type GetIpv6ReceiveTrafficClassResponseFut = fidl::client::QueryResponseFut<
6276        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
6277        fidl::encoding::DefaultFuchsiaResourceDialect,
6278    >;
6279    fn r#get_ipv6_receive_traffic_class(&self) -> Self::GetIpv6ReceiveTrafficClassResponseFut {
6280        fn _decode(
6281            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6282        ) -> Result<
6283            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
6284            fidl::Error,
6285        > {
6286            let _response = fidl::client::decode_transaction_body::<
6287                fidl::encoding::ResultType<
6288                    fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
6289                    fidl_fuchsia_posix::Errno,
6290                >,
6291                fidl::encoding::DefaultFuchsiaResourceDialect,
6292                0x2e334df1da553ffa,
6293            >(_buf?)?;
6294            Ok(_response.map(|x| x.value))
6295        }
6296        self.client.send_query_and_decode::<
6297            fidl::encoding::EmptyPayload,
6298            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
6299        >(
6300            (),
6301            0x2e334df1da553ffa,
6302            fidl::encoding::DynamicFlags::empty(),
6303            _decode,
6304        )
6305    }
6306
6307    type SetIpv6TrafficClassResponseFut = fidl::client::QueryResponseFut<
6308        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6TrafficClassResult,
6309        fidl::encoding::DefaultFuchsiaResourceDialect,
6310    >;
6311    fn r#set_ipv6_traffic_class(
6312        &self,
6313        mut value: &fidl_fuchsia_posix_socket::OptionalUint8,
6314    ) -> Self::SetIpv6TrafficClassResponseFut {
6315        fn _decode(
6316            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6317        ) -> Result<
6318            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6TrafficClassResult,
6319            fidl::Error,
6320        > {
6321            let _response = fidl::client::decode_transaction_body::<
6322                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
6323                fidl::encoding::DefaultFuchsiaResourceDialect,
6324                0x6af077800c5a0b4f,
6325            >(_buf?)?;
6326            Ok(_response.map(|x| x))
6327        }
6328        self.client.send_query_and_decode::<
6329            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6TrafficClassRequest,
6330            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6TrafficClassResult,
6331        >(
6332            (value,),
6333            0x6af077800c5a0b4f,
6334            fidl::encoding::DynamicFlags::empty(),
6335            _decode,
6336        )
6337    }
6338
6339    type GetIpv6TrafficClassResponseFut = fidl::client::QueryResponseFut<
6340        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6TrafficClassResult,
6341        fidl::encoding::DefaultFuchsiaResourceDialect,
6342    >;
6343    fn r#get_ipv6_traffic_class(&self) -> Self::GetIpv6TrafficClassResponseFut {
6344        fn _decode(
6345            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6346        ) -> Result<
6347            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6TrafficClassResult,
6348            fidl::Error,
6349        > {
6350            let _response = fidl::client::decode_transaction_body::<
6351                fidl::encoding::ResultType<
6352                    fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6TrafficClassResponse,
6353                    fidl_fuchsia_posix::Errno,
6354                >,
6355                fidl::encoding::DefaultFuchsiaResourceDialect,
6356                0x6baf6eed8fc2f04,
6357            >(_buf?)?;
6358            Ok(_response.map(|x| x.value))
6359        }
6360        self.client.send_query_and_decode::<
6361            fidl::encoding::EmptyPayload,
6362            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6TrafficClassResult,
6363        >(
6364            (),
6365            0x6baf6eed8fc2f04,
6366            fidl::encoding::DynamicFlags::empty(),
6367            _decode,
6368        )
6369    }
6370
6371    type SetIpv6ReceivePacketInfoResponseFut = fidl::client::QueryResponseFut<
6372        fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
6373        fidl::encoding::DefaultFuchsiaResourceDialect,
6374    >;
6375    fn r#set_ipv6_receive_packet_info(
6376        &self,
6377        mut value: bool,
6378    ) -> Self::SetIpv6ReceivePacketInfoResponseFut {
6379        fn _decode(
6380            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6381        ) -> Result<
6382            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
6383            fidl::Error,
6384        > {
6385            let _response = fidl::client::decode_transaction_body::<
6386                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
6387                fidl::encoding::DefaultFuchsiaResourceDialect,
6388                0x19259775b1a92768,
6389            >(_buf?)?;
6390            Ok(_response.map(|x| x))
6391        }
6392        self.client.send_query_and_decode::<
6393            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceivePacketInfoRequest,
6394            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
6395        >(
6396            (value,),
6397            0x19259775b1a92768,
6398            fidl::encoding::DynamicFlags::empty(),
6399            _decode,
6400        )
6401    }
6402
6403    type GetIpv6ReceivePacketInfoResponseFut = fidl::client::QueryResponseFut<
6404        fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
6405        fidl::encoding::DefaultFuchsiaResourceDialect,
6406    >;
6407    fn r#get_ipv6_receive_packet_info(&self) -> Self::GetIpv6ReceivePacketInfoResponseFut {
6408        fn _decode(
6409            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6410        ) -> Result<
6411            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
6412            fidl::Error,
6413        > {
6414            let _response = fidl::client::decode_transaction_body::<
6415                fidl::encoding::ResultType<
6416                    fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
6417                    fidl_fuchsia_posix::Errno,
6418                >,
6419                fidl::encoding::DefaultFuchsiaResourceDialect,
6420                0x7acd4a2775baec75,
6421            >(_buf?)?;
6422            Ok(_response.map(|x| x.value))
6423        }
6424        self.client.send_query_and_decode::<
6425            fidl::encoding::EmptyPayload,
6426            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
6427        >(
6428            (),
6429            0x7acd4a2775baec75,
6430            fidl::encoding::DynamicFlags::empty(),
6431            _decode,
6432        )
6433    }
6434
6435    type GetOriginalDestinationResponseFut = fidl::client::QueryResponseFut<
6436        fidl_fuchsia_posix_socket::BaseNetworkSocketGetOriginalDestinationResult,
6437        fidl::encoding::DefaultFuchsiaResourceDialect,
6438    >;
6439    fn r#get_original_destination(&self) -> Self::GetOriginalDestinationResponseFut {
6440        fn _decode(
6441            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6442        ) -> Result<
6443            fidl_fuchsia_posix_socket::BaseNetworkSocketGetOriginalDestinationResult,
6444            fidl::Error,
6445        > {
6446            let _response = fidl::client::decode_transaction_body::<
6447                fidl::encoding::ResultType<
6448                    fidl_fuchsia_posix_socket::BaseNetworkSocketGetOriginalDestinationResponse,
6449                    fidl_fuchsia_posix::Errno,
6450                >,
6451                fidl::encoding::DefaultFuchsiaResourceDialect,
6452                0x38bf28f0dafdbac0,
6453            >(_buf?)?;
6454            Ok(_response.map(|x| x.value))
6455        }
6456        self.client.send_query_and_decode::<
6457            fidl::encoding::EmptyPayload,
6458            fidl_fuchsia_posix_socket::BaseNetworkSocketGetOriginalDestinationResult,
6459        >(
6460            (),
6461            0x38bf28f0dafdbac0,
6462            fidl::encoding::DynamicFlags::empty(),
6463            _decode,
6464        )
6465    }
6466
6467    type DescribeResponseFut = fidl::client::QueryResponseFut<
6468        SocketDescribeResponse,
6469        fidl::encoding::DefaultFuchsiaResourceDialect,
6470    >;
6471    fn r#describe(&self) -> Self::DescribeResponseFut {
6472        fn _decode(
6473            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6474        ) -> Result<SocketDescribeResponse, fidl::Error> {
6475            let _response = fidl::client::decode_transaction_body::<
6476                SocketDescribeResponse,
6477                fidl::encoding::DefaultFuchsiaResourceDialect,
6478                0x335706eccf54a135,
6479            >(_buf?)?;
6480            Ok(_response)
6481        }
6482        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, SocketDescribeResponse>(
6483            (),
6484            0x335706eccf54a135,
6485            fidl::encoding::DynamicFlags::empty(),
6486            _decode,
6487        )
6488    }
6489
6490    type RecvMsgResponseFut = fidl::client::QueryResponseFut<
6491        SocketRecvMsgResult,
6492        fidl::encoding::DefaultFuchsiaResourceDialect,
6493    >;
6494    fn r#recv_msg(
6495        &self,
6496        mut want_addr: bool,
6497        mut data_len: u32,
6498        mut want_control: bool,
6499        mut flags: fidl_fuchsia_posix_socket::RecvMsgFlags,
6500    ) -> Self::RecvMsgResponseFut {
6501        fn _decode(
6502            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6503        ) -> Result<SocketRecvMsgResult, fidl::Error> {
6504            let _response = fidl::client::decode_transaction_body::<
6505                fidl::encoding::ResultType<SocketRecvMsgResponse, fidl_fuchsia_posix::Errno>,
6506                fidl::encoding::DefaultFuchsiaResourceDialect,
6507                0x1dfb695351d3aa1d,
6508            >(_buf?)?;
6509            Ok(_response.map(|x| (x.addr, x.data, x.control, x.truncated)))
6510        }
6511        self.client.send_query_and_decode::<SocketRecvMsgRequest, SocketRecvMsgResult>(
6512            (want_addr, data_len, want_control, flags),
6513            0x1dfb695351d3aa1d,
6514            fidl::encoding::DynamicFlags::empty(),
6515            _decode,
6516        )
6517    }
6518
6519    type SendMsgResponseFut = fidl::client::QueryResponseFut<
6520        SocketSendMsgResult,
6521        fidl::encoding::DefaultFuchsiaResourceDialect,
6522    >;
6523    fn r#send_msg(
6524        &self,
6525        mut addr: Option<&fidl_fuchsia_net::SocketAddress>,
6526        mut data: &[u8],
6527        mut control: &fidl_fuchsia_posix_socket::NetworkSocketSendControlData,
6528        mut flags: fidl_fuchsia_posix_socket::SendMsgFlags,
6529    ) -> Self::SendMsgResponseFut {
6530        fn _decode(
6531            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6532        ) -> Result<SocketSendMsgResult, fidl::Error> {
6533            let _response = fidl::client::decode_transaction_body::<
6534                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
6535                fidl::encoding::DefaultFuchsiaResourceDialect,
6536                0x2cf1eac9a7fc8958,
6537            >(_buf?)?;
6538            Ok(_response.map(|x| x))
6539        }
6540        self.client.send_query_and_decode::<SocketSendMsgRequest, SocketSendMsgResult>(
6541            (addr, data, control, flags),
6542            0x2cf1eac9a7fc8958,
6543            fidl::encoding::DynamicFlags::empty(),
6544            _decode,
6545        )
6546    }
6547
6548    type GetInfoResponseFut = fidl::client::QueryResponseFut<
6549        SocketGetInfoResult,
6550        fidl::encoding::DefaultFuchsiaResourceDialect,
6551    >;
6552    fn r#get_info(&self) -> Self::GetInfoResponseFut {
6553        fn _decode(
6554            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6555        ) -> Result<SocketGetInfoResult, fidl::Error> {
6556            let _response = fidl::client::decode_transaction_body::<
6557                fidl::encoding::ResultType<SocketGetInfoResponse, fidl_fuchsia_posix::Errno>,
6558                fidl::encoding::DefaultFuchsiaResourceDialect,
6559                0x39676f75aec339ba,
6560            >(_buf?)?;
6561            Ok(_response.map(|x| (x.domain, x.proto)))
6562        }
6563        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, SocketGetInfoResult>(
6564            (),
6565            0x39676f75aec339ba,
6566            fidl::encoding::DynamicFlags::empty(),
6567            _decode,
6568        )
6569    }
6570
6571    type SetIpHeaderIncludedResponseFut = fidl::client::QueryResponseFut<
6572        SocketSetIpHeaderIncludedResult,
6573        fidl::encoding::DefaultFuchsiaResourceDialect,
6574    >;
6575    fn r#set_ip_header_included(&self, mut value: bool) -> Self::SetIpHeaderIncludedResponseFut {
6576        fn _decode(
6577            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6578        ) -> Result<SocketSetIpHeaderIncludedResult, fidl::Error> {
6579            let _response = fidl::client::decode_transaction_body::<
6580                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
6581                fidl::encoding::DefaultFuchsiaResourceDialect,
6582                0x5d06a606d95e8f3,
6583            >(_buf?)?;
6584            Ok(_response.map(|x| x))
6585        }
6586        self.client.send_query_and_decode::<
6587            SocketSetIpHeaderIncludedRequest,
6588            SocketSetIpHeaderIncludedResult,
6589        >(
6590            (value,),
6591            0x5d06a606d95e8f3,
6592            fidl::encoding::DynamicFlags::empty(),
6593            _decode,
6594        )
6595    }
6596
6597    type GetIpHeaderIncludedResponseFut = fidl::client::QueryResponseFut<
6598        SocketGetIpHeaderIncludedResult,
6599        fidl::encoding::DefaultFuchsiaResourceDialect,
6600    >;
6601    fn r#get_ip_header_included(&self) -> Self::GetIpHeaderIncludedResponseFut {
6602        fn _decode(
6603            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6604        ) -> Result<SocketGetIpHeaderIncludedResult, fidl::Error> {
6605            let _response = fidl::client::decode_transaction_body::<
6606                fidl::encoding::ResultType<
6607                    SocketGetIpHeaderIncludedResponse,
6608                    fidl_fuchsia_posix::Errno,
6609                >,
6610                fidl::encoding::DefaultFuchsiaResourceDialect,
6611                0x76125ad1f4d175f6,
6612            >(_buf?)?;
6613            Ok(_response.map(|x| x.value))
6614        }
6615        self.client
6616            .send_query_and_decode::<fidl::encoding::EmptyPayload, SocketGetIpHeaderIncludedResult>(
6617                (),
6618                0x76125ad1f4d175f6,
6619                fidl::encoding::DynamicFlags::empty(),
6620                _decode,
6621            )
6622    }
6623
6624    type SetIcmpv6FilterResponseFut = fidl::client::QueryResponseFut<
6625        SocketSetIcmpv6FilterResult,
6626        fidl::encoding::DefaultFuchsiaResourceDialect,
6627    >;
6628    fn r#set_icmpv6_filter(&self, mut filter: &Icmpv6Filter) -> Self::SetIcmpv6FilterResponseFut {
6629        fn _decode(
6630            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6631        ) -> Result<SocketSetIcmpv6FilterResult, fidl::Error> {
6632            let _response = fidl::client::decode_transaction_body::<
6633                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
6634                fidl::encoding::DefaultFuchsiaResourceDialect,
6635                0x4ebea92a43ae68a9,
6636            >(_buf?)?;
6637            Ok(_response.map(|x| x))
6638        }
6639        self.client
6640            .send_query_and_decode::<SocketSetIcmpv6FilterRequest, SocketSetIcmpv6FilterResult>(
6641                (filter,),
6642                0x4ebea92a43ae68a9,
6643                fidl::encoding::DynamicFlags::empty(),
6644                _decode,
6645            )
6646    }
6647
6648    type GetIcmpv6FilterResponseFut = fidl::client::QueryResponseFut<
6649        SocketGetIcmpv6FilterResult,
6650        fidl::encoding::DefaultFuchsiaResourceDialect,
6651    >;
6652    fn r#get_icmpv6_filter(&self) -> Self::GetIcmpv6FilterResponseFut {
6653        fn _decode(
6654            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6655        ) -> Result<SocketGetIcmpv6FilterResult, fidl::Error> {
6656            let _response = fidl::client::decode_transaction_body::<
6657                fidl::encoding::ResultType<
6658                    SocketGetIcmpv6FilterResponse,
6659                    fidl_fuchsia_posix::Errno,
6660                >,
6661                fidl::encoding::DefaultFuchsiaResourceDialect,
6662                0x43bd4f3bc0970ace,
6663            >(_buf?)?;
6664            Ok(_response.map(|x| x.filter))
6665        }
6666        self.client
6667            .send_query_and_decode::<fidl::encoding::EmptyPayload, SocketGetIcmpv6FilterResult>(
6668                (),
6669                0x43bd4f3bc0970ace,
6670                fidl::encoding::DynamicFlags::empty(),
6671                _decode,
6672            )
6673    }
6674
6675    type SetIpv6ChecksumResponseFut = fidl::client::QueryResponseFut<
6676        SocketSetIpv6ChecksumResult,
6677        fidl::encoding::DefaultFuchsiaResourceDialect,
6678    >;
6679    fn r#set_ipv6_checksum(
6680        &self,
6681        mut config: &Ipv6ChecksumConfiguration,
6682    ) -> Self::SetIpv6ChecksumResponseFut {
6683        fn _decode(
6684            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6685        ) -> Result<SocketSetIpv6ChecksumResult, fidl::Error> {
6686            let _response = fidl::client::decode_transaction_body::<
6687                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
6688                fidl::encoding::DefaultFuchsiaResourceDialect,
6689                0x18b7809577199cb4,
6690            >(_buf?)?;
6691            Ok(_response.map(|x| x))
6692        }
6693        self.client
6694            .send_query_and_decode::<SocketSetIpv6ChecksumRequest, SocketSetIpv6ChecksumResult>(
6695                (config,),
6696                0x18b7809577199cb4,
6697                fidl::encoding::DynamicFlags::empty(),
6698                _decode,
6699            )
6700    }
6701
6702    type GetIpv6ChecksumResponseFut = fidl::client::QueryResponseFut<
6703        SocketGetIpv6ChecksumResult,
6704        fidl::encoding::DefaultFuchsiaResourceDialect,
6705    >;
6706    fn r#get_ipv6_checksum(&self) -> Self::GetIpv6ChecksumResponseFut {
6707        fn _decode(
6708            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
6709        ) -> Result<SocketGetIpv6ChecksumResult, fidl::Error> {
6710            let _response = fidl::client::decode_transaction_body::<
6711                fidl::encoding::ResultType<
6712                    SocketGetIpv6ChecksumResponse,
6713                    fidl_fuchsia_posix::Errno,
6714                >,
6715                fidl::encoding::DefaultFuchsiaResourceDialect,
6716                0x1847bf5b2d263dd,
6717            >(_buf?)?;
6718            Ok(_response.map(|x| x.config))
6719        }
6720        self.client
6721            .send_query_and_decode::<fidl::encoding::EmptyPayload, SocketGetIpv6ChecksumResult>(
6722                (),
6723                0x1847bf5b2d263dd,
6724                fidl::encoding::DynamicFlags::empty(),
6725                _decode,
6726            )
6727    }
6728}
6729
6730pub struct SocketEventStream {
6731    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
6732}
6733
6734impl std::marker::Unpin for SocketEventStream {}
6735
6736impl futures::stream::FusedStream for SocketEventStream {
6737    fn is_terminated(&self) -> bool {
6738        self.event_receiver.is_terminated()
6739    }
6740}
6741
6742impl futures::Stream for SocketEventStream {
6743    type Item = Result<SocketEvent, fidl::Error>;
6744
6745    fn poll_next(
6746        mut self: std::pin::Pin<&mut Self>,
6747        cx: &mut std::task::Context<'_>,
6748    ) -> std::task::Poll<Option<Self::Item>> {
6749        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
6750            &mut self.event_receiver,
6751            cx
6752        )?) {
6753            Some(buf) => std::task::Poll::Ready(Some(SocketEvent::decode(buf))),
6754            None => std::task::Poll::Ready(None),
6755        }
6756    }
6757}
6758
6759#[derive(Debug)]
6760pub enum SocketEvent {}
6761
6762impl SocketEvent {
6763    /// Decodes a message buffer as a [`SocketEvent`].
6764    fn decode(
6765        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
6766    ) -> Result<SocketEvent, fidl::Error> {
6767        let (bytes, _handles) = buf.split_mut();
6768        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
6769        debug_assert_eq!(tx_header.tx_id, 0);
6770        match tx_header.ordinal {
6771            _ => Err(fidl::Error::UnknownOrdinal {
6772                ordinal: tx_header.ordinal,
6773                protocol_name: <SocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
6774            }),
6775        }
6776    }
6777}
6778
6779/// A Stream of incoming requests for fuchsia.posix.socket.raw/Socket.
6780pub struct SocketRequestStream {
6781    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
6782    is_terminated: bool,
6783}
6784
6785impl std::marker::Unpin for SocketRequestStream {}
6786
6787impl futures::stream::FusedStream for SocketRequestStream {
6788    fn is_terminated(&self) -> bool {
6789        self.is_terminated
6790    }
6791}
6792
6793impl fidl::endpoints::RequestStream for SocketRequestStream {
6794    type Protocol = SocketMarker;
6795    type ControlHandle = SocketControlHandle;
6796
6797    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
6798        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
6799    }
6800
6801    fn control_handle(&self) -> Self::ControlHandle {
6802        SocketControlHandle { inner: self.inner.clone() }
6803    }
6804
6805    fn into_inner(
6806        self,
6807    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
6808    {
6809        (self.inner, self.is_terminated)
6810    }
6811
6812    fn from_inner(
6813        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
6814        is_terminated: bool,
6815    ) -> Self {
6816        Self { inner, is_terminated }
6817    }
6818}
6819
6820impl futures::Stream for SocketRequestStream {
6821    type Item = Result<SocketRequest, fidl::Error>;
6822
6823    fn poll_next(
6824        mut self: std::pin::Pin<&mut Self>,
6825        cx: &mut std::task::Context<'_>,
6826    ) -> std::task::Poll<Option<Self::Item>> {
6827        let this = &mut *self;
6828        if this.inner.check_shutdown(cx) {
6829            this.is_terminated = true;
6830            return std::task::Poll::Ready(None);
6831        }
6832        if this.is_terminated {
6833            panic!("polled SocketRequestStream after completion");
6834        }
6835        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
6836            |bytes, handles| {
6837                match this.inner.channel().read_etc(cx, bytes, handles) {
6838                    std::task::Poll::Ready(Ok(())) => {}
6839                    std::task::Poll::Pending => return std::task::Poll::Pending,
6840                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
6841                        this.is_terminated = true;
6842                        return std::task::Poll::Ready(None);
6843                    }
6844                    std::task::Poll::Ready(Err(e)) => {
6845                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
6846                            e.into(),
6847                        ))))
6848                    }
6849                }
6850
6851                // A message has been received from the channel
6852                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
6853
6854                std::task::Poll::Ready(Some(match header.ordinal {
6855                    0x20d8a7aba2168a79 => {
6856                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
6857                        let mut req = fidl::new_empty!(
6858                            fidl_fuchsia_unknown::CloneableCloneRequest,
6859                            fidl::encoding::DefaultFuchsiaResourceDialect
6860                        );
6861                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_unknown::CloneableCloneRequest>(&header, _body_bytes, handles, &mut req)?;
6862                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
6863                        Ok(SocketRequest::Clone { request: req.request, control_handle })
6864                    }
6865                    0x5ac5d459ad7f657e => {
6866                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6867                        let mut req = fidl::new_empty!(
6868                            fidl::encoding::EmptyPayload,
6869                            fidl::encoding::DefaultFuchsiaResourceDialect
6870                        );
6871                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
6872                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
6873                        Ok(SocketRequest::Close {
6874                            responder: SocketCloseResponder {
6875                                control_handle: std::mem::ManuallyDrop::new(control_handle),
6876                                tx_id: header.tx_id,
6877                            },
6878                        })
6879                    }
6880                    0x2658edee9decfc06 => {
6881                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6882                        let mut req = fidl::new_empty!(
6883                            fidl::encoding::EmptyPayload,
6884                            fidl::encoding::DefaultFuchsiaResourceDialect
6885                        );
6886                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
6887                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
6888                        Ok(SocketRequest::Query {
6889                            responder: SocketQueryResponder {
6890                                control_handle: std::mem::ManuallyDrop::new(control_handle),
6891                                tx_id: header.tx_id,
6892                            },
6893                        })
6894                    }
6895                    0x1fd74ee8b9a4a876 => {
6896                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6897                        let mut req = fidl::new_empty!(
6898                            fidl_fuchsia_posix_socket::BaseSocketSetReuseAddressRequest,
6899                            fidl::encoding::DefaultFuchsiaResourceDialect
6900                        );
6901                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseSocketSetReuseAddressRequest>(&header, _body_bytes, handles, &mut req)?;
6902                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
6903                        Ok(SocketRequest::SetReuseAddress {
6904                            value: req.value,
6905
6906                            responder: SocketSetReuseAddressResponder {
6907                                control_handle: std::mem::ManuallyDrop::new(control_handle),
6908                                tx_id: header.tx_id,
6909                            },
6910                        })
6911                    }
6912                    0x67b7206b8d1bc0a5 => {
6913                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6914                        let mut req = fidl::new_empty!(
6915                            fidl::encoding::EmptyPayload,
6916                            fidl::encoding::DefaultFuchsiaResourceDialect
6917                        );
6918                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
6919                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
6920                        Ok(SocketRequest::GetReuseAddress {
6921                            responder: SocketGetReuseAddressResponder {
6922                                control_handle: std::mem::ManuallyDrop::new(control_handle),
6923                                tx_id: header.tx_id,
6924                            },
6925                        })
6926                    }
6927                    0x5aad39b33e5f6ebb => {
6928                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6929                        let mut req = fidl::new_empty!(
6930                            fidl::encoding::EmptyPayload,
6931                            fidl::encoding::DefaultFuchsiaResourceDialect
6932                        );
6933                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
6934                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
6935                        Ok(SocketRequest::GetError {
6936                            responder: SocketGetErrorResponder {
6937                                control_handle: std::mem::ManuallyDrop::new(control_handle),
6938                                tx_id: header.tx_id,
6939                            },
6940                        })
6941                    }
6942                    0x6023e081ce3cd947 => {
6943                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6944                        let mut req = fidl::new_empty!(
6945                            fidl_fuchsia_posix_socket::BaseSocketSetBroadcastRequest,
6946                            fidl::encoding::DefaultFuchsiaResourceDialect
6947                        );
6948                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseSocketSetBroadcastRequest>(&header, _body_bytes, handles, &mut req)?;
6949                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
6950                        Ok(SocketRequest::SetBroadcast {
6951                            value: req.value,
6952
6953                            responder: SocketSetBroadcastResponder {
6954                                control_handle: std::mem::ManuallyDrop::new(control_handle),
6955                                tx_id: header.tx_id,
6956                            },
6957                        })
6958                    }
6959                    0x68796fc556f9780d => {
6960                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6961                        let mut req = fidl::new_empty!(
6962                            fidl::encoding::EmptyPayload,
6963                            fidl::encoding::DefaultFuchsiaResourceDialect
6964                        );
6965                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
6966                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
6967                        Ok(SocketRequest::GetBroadcast {
6968                            responder: SocketGetBroadcastResponder {
6969                                control_handle: std::mem::ManuallyDrop::new(control_handle),
6970                                tx_id: header.tx_id,
6971                            },
6972                        })
6973                    }
6974                    0x756eac32d73a7a70 => {
6975                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6976                        let mut req = fidl::new_empty!(
6977                            fidl_fuchsia_posix_socket::BaseSocketSetSendBufferRequest,
6978                            fidl::encoding::DefaultFuchsiaResourceDialect
6979                        );
6980                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseSocketSetSendBufferRequest>(&header, _body_bytes, handles, &mut req)?;
6981                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
6982                        Ok(SocketRequest::SetSendBuffer {
6983                            value_bytes: req.value_bytes,
6984
6985                            responder: SocketSetSendBufferResponder {
6986                                control_handle: std::mem::ManuallyDrop::new(control_handle),
6987                                tx_id: header.tx_id,
6988                            },
6989                        })
6990                    }
6991                    0x78a52fd9c7b2410b => {
6992                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6993                        let mut req = fidl::new_empty!(
6994                            fidl::encoding::EmptyPayload,
6995                            fidl::encoding::DefaultFuchsiaResourceDialect
6996                        );
6997                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
6998                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
6999                        Ok(SocketRequest::GetSendBuffer {
7000                            responder: SocketGetSendBufferResponder {
7001                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7002                                tx_id: header.tx_id,
7003                            },
7004                        })
7005                    }
7006                    0x6b0cf2f1919c7001 => {
7007                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7008                        let mut req = fidl::new_empty!(
7009                            fidl_fuchsia_posix_socket::BaseSocketSetReceiveBufferRequest,
7010                            fidl::encoding::DefaultFuchsiaResourceDialect
7011                        );
7012                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseSocketSetReceiveBufferRequest>(&header, _body_bytes, handles, &mut req)?;
7013                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7014                        Ok(SocketRequest::SetReceiveBuffer {
7015                            value_bytes: req.value_bytes,
7016
7017                            responder: SocketSetReceiveBufferResponder {
7018                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7019                                tx_id: header.tx_id,
7020                            },
7021                        })
7022                    }
7023                    0x14c1a4b64f709e5c => {
7024                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7025                        let mut req = fidl::new_empty!(
7026                            fidl::encoding::EmptyPayload,
7027                            fidl::encoding::DefaultFuchsiaResourceDialect
7028                        );
7029                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7030                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7031                        Ok(SocketRequest::GetReceiveBuffer {
7032                            responder: SocketGetReceiveBufferResponder {
7033                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7034                                tx_id: header.tx_id,
7035                            },
7036                        })
7037                    }
7038                    0x572df8f0b920d2c7 => {
7039                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7040                        let mut req = fidl::new_empty!(
7041                            fidl_fuchsia_posix_socket::BaseSocketSetKeepAliveRequest,
7042                            fidl::encoding::DefaultFuchsiaResourceDialect
7043                        );
7044                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseSocketSetKeepAliveRequest>(&header, _body_bytes, handles, &mut req)?;
7045                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7046                        Ok(SocketRequest::SetKeepAlive {
7047                            value: req.value,
7048
7049                            responder: SocketSetKeepAliveResponder {
7050                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7051                                tx_id: header.tx_id,
7052                            },
7053                        })
7054                    }
7055                    0x2dd29d3215f2c9d2 => {
7056                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7057                        let mut req = fidl::new_empty!(
7058                            fidl::encoding::EmptyPayload,
7059                            fidl::encoding::DefaultFuchsiaResourceDialect
7060                        );
7061                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7062                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7063                        Ok(SocketRequest::GetKeepAlive {
7064                            responder: SocketGetKeepAliveResponder {
7065                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7066                                tx_id: header.tx_id,
7067                            },
7068                        })
7069                    }
7070                    0x3ecb49968bee439 => {
7071                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7072                        let mut req = fidl::new_empty!(
7073                            fidl_fuchsia_posix_socket::BaseSocketSetOutOfBandInlineRequest,
7074                            fidl::encoding::DefaultFuchsiaResourceDialect
7075                        );
7076                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseSocketSetOutOfBandInlineRequest>(&header, _body_bytes, handles, &mut req)?;
7077                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7078                        Ok(SocketRequest::SetOutOfBandInline {
7079                            value: req.value,
7080
7081                            responder: SocketSetOutOfBandInlineResponder {
7082                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7083                                tx_id: header.tx_id,
7084                            },
7085                        })
7086                    }
7087                    0x348c1ab3aeca1745 => {
7088                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7089                        let mut req = fidl::new_empty!(
7090                            fidl::encoding::EmptyPayload,
7091                            fidl::encoding::DefaultFuchsiaResourceDialect
7092                        );
7093                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7094                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7095                        Ok(SocketRequest::GetOutOfBandInline {
7096                            responder: SocketGetOutOfBandInlineResponder {
7097                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7098                                tx_id: header.tx_id,
7099                            },
7100                        })
7101                    }
7102                    0x6bbf00c53a4c78c2 => {
7103                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7104                        let mut req = fidl::new_empty!(
7105                            fidl_fuchsia_posix_socket::BaseSocketSetNoCheckRequest,
7106                            fidl::encoding::DefaultFuchsiaResourceDialect
7107                        );
7108                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseSocketSetNoCheckRequest>(&header, _body_bytes, handles, &mut req)?;
7109                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7110                        Ok(SocketRequest::SetNoCheck {
7111                            value: req.value,
7112
7113                            responder: SocketSetNoCheckResponder {
7114                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7115                                tx_id: header.tx_id,
7116                            },
7117                        })
7118                    }
7119                    0x2cd4249286417694 => {
7120                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7121                        let mut req = fidl::new_empty!(
7122                            fidl::encoding::EmptyPayload,
7123                            fidl::encoding::DefaultFuchsiaResourceDialect
7124                        );
7125                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7126                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7127                        Ok(SocketRequest::GetNoCheck {
7128                            responder: SocketGetNoCheckResponder {
7129                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7130                                tx_id: header.tx_id,
7131                            },
7132                        })
7133                    }
7134                    0x45386351246e998e => {
7135                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7136                        let mut req = fidl::new_empty!(
7137                            fidl_fuchsia_posix_socket::BaseSocketSetLingerRequest,
7138                            fidl::encoding::DefaultFuchsiaResourceDialect
7139                        );
7140                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseSocketSetLingerRequest>(&header, _body_bytes, handles, &mut req)?;
7141                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7142                        Ok(SocketRequest::SetLinger {
7143                            linger: req.linger,
7144                            length_secs: req.length_secs,
7145
7146                            responder: SocketSetLingerResponder {
7147                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7148                                tx_id: header.tx_id,
7149                            },
7150                        })
7151                    }
7152                    0x48eb20fc5ccb0e45 => {
7153                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7154                        let mut req = fidl::new_empty!(
7155                            fidl::encoding::EmptyPayload,
7156                            fidl::encoding::DefaultFuchsiaResourceDialect
7157                        );
7158                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7159                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7160                        Ok(SocketRequest::GetLinger {
7161                            responder: SocketGetLingerResponder {
7162                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7163                                tx_id: header.tx_id,
7164                            },
7165                        })
7166                    }
7167                    0x24dd3e5cb36d9ccb => {
7168                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7169                        let mut req = fidl::new_empty!(
7170                            fidl_fuchsia_posix_socket::BaseSocketSetReusePortRequest,
7171                            fidl::encoding::DefaultFuchsiaResourceDialect
7172                        );
7173                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseSocketSetReusePortRequest>(&header, _body_bytes, handles, &mut req)?;
7174                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7175                        Ok(SocketRequest::SetReusePort {
7176                            value: req.value,
7177
7178                            responder: SocketSetReusePortResponder {
7179                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7180                                tx_id: header.tx_id,
7181                            },
7182                        })
7183                    }
7184                    0x7a112c1ab54ff828 => {
7185                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7186                        let mut req = fidl::new_empty!(
7187                            fidl::encoding::EmptyPayload,
7188                            fidl::encoding::DefaultFuchsiaResourceDialect
7189                        );
7190                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7191                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7192                        Ok(SocketRequest::GetReusePort {
7193                            responder: SocketGetReusePortResponder {
7194                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7195                                tx_id: header.tx_id,
7196                            },
7197                        })
7198                    }
7199                    0x67ce6db6c2ec8966 => {
7200                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7201                        let mut req = fidl::new_empty!(
7202                            fidl::encoding::EmptyPayload,
7203                            fidl::encoding::DefaultFuchsiaResourceDialect
7204                        );
7205                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7206                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7207                        Ok(SocketRequest::GetAcceptConn {
7208                            responder: SocketGetAcceptConnResponder {
7209                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7210                                tx_id: header.tx_id,
7211                            },
7212                        })
7213                    }
7214                    0x2118b483f28aafc4 => {
7215                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7216                        let mut req = fidl::new_empty!(
7217                            fidl_fuchsia_posix_socket::BaseSocketSetBindToDeviceRequest,
7218                            fidl::encoding::DefaultFuchsiaResourceDialect
7219                        );
7220                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseSocketSetBindToDeviceRequest>(&header, _body_bytes, handles, &mut req)?;
7221                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7222                        Ok(SocketRequest::SetBindToDevice {
7223                            value: req.value,
7224
7225                            responder: SocketSetBindToDeviceResponder {
7226                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7227                                tx_id: header.tx_id,
7228                            },
7229                        })
7230                    }
7231                    0x1ab1fbf0ef7906c8 => {
7232                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7233                        let mut req = fidl::new_empty!(
7234                            fidl::encoding::EmptyPayload,
7235                            fidl::encoding::DefaultFuchsiaResourceDialect
7236                        );
7237                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7238                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7239                        Ok(SocketRequest::GetBindToDevice {
7240                            responder: SocketGetBindToDeviceResponder {
7241                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7242                                tx_id: header.tx_id,
7243                            },
7244                        })
7245                    }
7246                    0x6e387a0def00821 => {
7247                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7248                        let mut req = fidl::new_empty!(
7249                            fidl_fuchsia_posix_socket::BaseSocketSetBindToInterfaceIndexRequest,
7250                            fidl::encoding::DefaultFuchsiaResourceDialect
7251                        );
7252                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseSocketSetBindToInterfaceIndexRequest>(&header, _body_bytes, handles, &mut req)?;
7253                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7254                        Ok(SocketRequest::SetBindToInterfaceIndex {
7255                            value: req.value,
7256
7257                            responder: SocketSetBindToInterfaceIndexResponder {
7258                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7259                                tx_id: header.tx_id,
7260                            },
7261                        })
7262                    }
7263                    0x59c31dd3e3078295 => {
7264                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7265                        let mut req = fidl::new_empty!(
7266                            fidl::encoding::EmptyPayload,
7267                            fidl::encoding::DefaultFuchsiaResourceDialect
7268                        );
7269                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7270                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7271                        Ok(SocketRequest::GetBindToInterfaceIndex {
7272                            responder: SocketGetBindToInterfaceIndexResponder {
7273                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7274                                tx_id: header.tx_id,
7275                            },
7276                        })
7277                    }
7278                    0x285d6516c263d839 => {
7279                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7280                        let mut req = fidl::new_empty!(
7281                            fidl_fuchsia_posix_socket::BaseSocketSetTimestampRequest,
7282                            fidl::encoding::DefaultFuchsiaResourceDialect
7283                        );
7284                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseSocketSetTimestampRequest>(&header, _body_bytes, handles, &mut req)?;
7285                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7286                        Ok(SocketRequest::SetTimestamp {
7287                            value: req.value,
7288
7289                            responder: SocketSetTimestampResponder {
7290                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7291                                tx_id: header.tx_id,
7292                            },
7293                        })
7294                    }
7295                    0x49f2fffbbcc2bd27 => {
7296                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7297                        let mut req = fidl::new_empty!(
7298                            fidl::encoding::EmptyPayload,
7299                            fidl::encoding::DefaultFuchsiaResourceDialect
7300                        );
7301                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7302                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7303                        Ok(SocketRequest::GetTimestamp {
7304                            responder: SocketGetTimestampResponder {
7305                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7306                                tx_id: header.tx_id,
7307                            },
7308                        })
7309                    }
7310                    0x6ead6de09f653236 => {
7311                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7312                        let mut req = fidl::new_empty!(
7313                            fidl_fuchsia_posix_socket::BaseSocketSetMarkRequest,
7314                            fidl::encoding::DefaultFuchsiaResourceDialect
7315                        );
7316                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseSocketSetMarkRequest>(&header, _body_bytes, handles, &mut req)?;
7317                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7318                        Ok(SocketRequest::SetMark {
7319                            domain: req.domain,
7320                            mark: req.mark,
7321
7322                            responder: SocketSetMarkResponder {
7323                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7324                                tx_id: header.tx_id,
7325                            },
7326                        })
7327                    }
7328                    0x57a2752c61d93d47 => {
7329                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7330                        let mut req = fidl::new_empty!(
7331                            fidl_fuchsia_posix_socket::BaseSocketGetMarkRequest,
7332                            fidl::encoding::DefaultFuchsiaResourceDialect
7333                        );
7334                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseSocketGetMarkRequest>(&header, _body_bytes, handles, &mut req)?;
7335                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7336                        Ok(SocketRequest::GetMark {
7337                            domain: req.domain,
7338
7339                            responder: SocketGetMarkResponder {
7340                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7341                                tx_id: header.tx_id,
7342                            },
7343                        })
7344                    }
7345                    0x2c2f47fd8f924e52 => {
7346                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7347                        let mut req = fidl::new_empty!(
7348                            fidl::encoding::EmptyPayload,
7349                            fidl::encoding::DefaultFuchsiaResourceDialect
7350                        );
7351                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7352                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7353                        Ok(SocketRequest::GetCookie {
7354                            responder: SocketGetCookieResponder {
7355                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7356                                tx_id: header.tx_id,
7357                            },
7358                        })
7359                    }
7360                    0x4bc6400ae92125d => {
7361                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7362                        let mut req = fidl::new_empty!(
7363                            fidl_fuchsia_posix_socket::BaseNetworkSocketBindRequest,
7364                            fidl::encoding::DefaultFuchsiaResourceDialect
7365                        );
7366                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketBindRequest>(&header, _body_bytes, handles, &mut req)?;
7367                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7368                        Ok(SocketRequest::Bind {
7369                            addr: req.addr,
7370
7371                            responder: SocketBindResponder {
7372                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7373                                tx_id: header.tx_id,
7374                            },
7375                        })
7376                    }
7377                    0x5f05f19bfdd38871 => {
7378                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7379                        let mut req = fidl::new_empty!(
7380                            fidl_fuchsia_posix_socket::BaseNetworkSocketConnectRequest,
7381                            fidl::encoding::DefaultFuchsiaResourceDialect
7382                        );
7383                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketConnectRequest>(&header, _body_bytes, handles, &mut req)?;
7384                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7385                        Ok(SocketRequest::Connect {
7386                            addr: req.addr,
7387
7388                            responder: SocketConnectResponder {
7389                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7390                                tx_id: header.tx_id,
7391                            },
7392                        })
7393                    }
7394                    0x74e63b91f7b29b2 => {
7395                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7396                        let mut req = fidl::new_empty!(
7397                            fidl::encoding::EmptyPayload,
7398                            fidl::encoding::DefaultFuchsiaResourceDialect
7399                        );
7400                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7401                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7402                        Ok(SocketRequest::Disconnect {
7403                            responder: SocketDisconnectResponder {
7404                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7405                                tx_id: header.tx_id,
7406                            },
7407                        })
7408                    }
7409                    0x475f23f84a1a4f85 => {
7410                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7411                        let mut req = fidl::new_empty!(
7412                            fidl::encoding::EmptyPayload,
7413                            fidl::encoding::DefaultFuchsiaResourceDialect
7414                        );
7415                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7416                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7417                        Ok(SocketRequest::GetSockName {
7418                            responder: SocketGetSockNameResponder {
7419                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7420                                tx_id: header.tx_id,
7421                            },
7422                        })
7423                    }
7424                    0x1ffecf4bd5b6432e => {
7425                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7426                        let mut req = fidl::new_empty!(
7427                            fidl::encoding::EmptyPayload,
7428                            fidl::encoding::DefaultFuchsiaResourceDialect
7429                        );
7430                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7431                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7432                        Ok(SocketRequest::GetPeerName {
7433                            responder: SocketGetPeerNameResponder {
7434                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7435                                tx_id: header.tx_id,
7436                            },
7437                        })
7438                    }
7439                    0x247f38b6db68c336 => {
7440                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7441                        let mut req = fidl::new_empty!(
7442                            fidl_fuchsia_posix_socket::BaseNetworkSocketShutdownRequest,
7443                            fidl::encoding::DefaultFuchsiaResourceDialect
7444                        );
7445                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketShutdownRequest>(&header, _body_bytes, handles, &mut req)?;
7446                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7447                        Ok(SocketRequest::Shutdown {
7448                            mode: req.mode,
7449
7450                            responder: SocketShutdownResponder {
7451                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7452                                tx_id: header.tx_id,
7453                            },
7454                        })
7455                    }
7456                    0x995c600475b6d46 => {
7457                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7458                        let mut req = fidl::new_empty!(
7459                            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTypeOfServiceRequest,
7460                            fidl::encoding::DefaultFuchsiaResourceDialect
7461                        );
7462                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTypeOfServiceRequest>(&header, _body_bytes, handles, &mut req)?;
7463                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7464                        Ok(SocketRequest::SetIpTypeOfService {
7465                            value: req.value,
7466
7467                            responder: SocketSetIpTypeOfServiceResponder {
7468                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7469                                tx_id: header.tx_id,
7470                            },
7471                        })
7472                    }
7473                    0x3814a04259f75fcb => {
7474                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7475                        let mut req = fidl::new_empty!(
7476                            fidl::encoding::EmptyPayload,
7477                            fidl::encoding::DefaultFuchsiaResourceDialect
7478                        );
7479                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7480                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7481                        Ok(SocketRequest::GetIpTypeOfService {
7482                            responder: SocketGetIpTypeOfServiceResponder {
7483                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7484                                tx_id: header.tx_id,
7485                            },
7486                        })
7487                    }
7488                    0x29e2424b433ae1ef => {
7489                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7490                        let mut req = fidl::new_empty!(
7491                            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTtlRequest,
7492                            fidl::encoding::DefaultFuchsiaResourceDialect
7493                        );
7494                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTtlRequest>(&header, _body_bytes, handles, &mut req)?;
7495                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7496                        Ok(SocketRequest::SetIpTtl {
7497                            value: req.value,
7498
7499                            responder: SocketSetIpTtlResponder {
7500                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7501                                tx_id: header.tx_id,
7502                            },
7503                        })
7504                    }
7505                    0x47e47fa1f24da471 => {
7506                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7507                        let mut req = fidl::new_empty!(
7508                            fidl::encoding::EmptyPayload,
7509                            fidl::encoding::DefaultFuchsiaResourceDialect
7510                        );
7511                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7512                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7513                        Ok(SocketRequest::GetIpTtl {
7514                            responder: SocketGetIpTtlResponder {
7515                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7516                                tx_id: header.tx_id,
7517                            },
7518                        })
7519                    }
7520                    0x392d16bee20c0e16 => {
7521                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7522                        let mut req = fidl::new_empty!(
7523                            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpPacketInfoRequest,
7524                            fidl::encoding::DefaultFuchsiaResourceDialect
7525                        );
7526                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpPacketInfoRequest>(&header, _body_bytes, handles, &mut req)?;
7527                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7528                        Ok(SocketRequest::SetIpPacketInfo {
7529                            value: req.value,
7530
7531                            responder: SocketSetIpPacketInfoResponder {
7532                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7533                                tx_id: header.tx_id,
7534                            },
7535                        })
7536                    }
7537                    0x54b505f242280740 => {
7538                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7539                        let mut req = fidl::new_empty!(
7540                            fidl::encoding::EmptyPayload,
7541                            fidl::encoding::DefaultFuchsiaResourceDialect
7542                        );
7543                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7544                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7545                        Ok(SocketRequest::GetIpPacketInfo {
7546                            responder: SocketGetIpPacketInfoResponder {
7547                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7548                                tx_id: header.tx_id,
7549                            },
7550                        })
7551                    }
7552                    0x6c4f6714995f84ef => {
7553                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7554                        let mut req = fidl::new_empty!(fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveTypeOfServiceRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
7555                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveTypeOfServiceRequest>(&header, _body_bytes, handles, &mut req)?;
7556                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7557                        Ok(SocketRequest::SetIpReceiveTypeOfService {
7558                            value: req.value,
7559
7560                            responder: SocketSetIpReceiveTypeOfServiceResponder {
7561                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7562                                tx_id: header.tx_id,
7563                            },
7564                        })
7565                    }
7566                    0x4158ba7dc2795960 => {
7567                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7568                        let mut req = fidl::new_empty!(
7569                            fidl::encoding::EmptyPayload,
7570                            fidl::encoding::DefaultFuchsiaResourceDialect
7571                        );
7572                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7573                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7574                        Ok(SocketRequest::GetIpReceiveTypeOfService {
7575                            responder: SocketGetIpReceiveTypeOfServiceResponder {
7576                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7577                                tx_id: header.tx_id,
7578                            },
7579                        })
7580                    }
7581                    0x46f15be0ce0ab82b => {
7582                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7583                        let mut req = fidl::new_empty!(
7584                            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveTtlRequest,
7585                            fidl::encoding::DefaultFuchsiaResourceDialect
7586                        );
7587                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveTtlRequest>(&header, _body_bytes, handles, &mut req)?;
7588                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7589                        Ok(SocketRequest::SetIpReceiveTtl {
7590                            value: req.value,
7591
7592                            responder: SocketSetIpReceiveTtlResponder {
7593                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7594                                tx_id: header.tx_id,
7595                            },
7596                        })
7597                    }
7598                    0x678ddd5a5dfa2eb5 => {
7599                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7600                        let mut req = fidl::new_empty!(
7601                            fidl::encoding::EmptyPayload,
7602                            fidl::encoding::DefaultFuchsiaResourceDialect
7603                        );
7604                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7605                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7606                        Ok(SocketRequest::GetIpReceiveTtl {
7607                            responder: SocketGetIpReceiveTtlResponder {
7608                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7609                                tx_id: header.tx_id,
7610                            },
7611                        })
7612                    }
7613                    0x752fbfa9b12befe => {
7614                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7615                        let mut req = fidl::new_empty!(fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastInterfaceRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
7616                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastInterfaceRequest>(&header, _body_bytes, handles, &mut req)?;
7617                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7618                        Ok(SocketRequest::SetIpMulticastInterface {
7619                            iface: req.iface,
7620                            address: req.address,
7621
7622                            responder: SocketSetIpMulticastInterfaceResponder {
7623                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7624                                tx_id: header.tx_id,
7625                            },
7626                        })
7627                    }
7628                    0x320bd14c4df046c4 => {
7629                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7630                        let mut req = fidl::new_empty!(
7631                            fidl::encoding::EmptyPayload,
7632                            fidl::encoding::DefaultFuchsiaResourceDialect
7633                        );
7634                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7635                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7636                        Ok(SocketRequest::GetIpMulticastInterface {
7637                            responder: SocketGetIpMulticastInterfaceResponder {
7638                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7639                                tx_id: header.tx_id,
7640                            },
7641                        })
7642                    }
7643                    0x63134d53772916a1 => {
7644                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7645                        let mut req = fidl::new_empty!(
7646                            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastTtlRequest,
7647                            fidl::encoding::DefaultFuchsiaResourceDialect
7648                        );
7649                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastTtlRequest>(&header, _body_bytes, handles, &mut req)?;
7650                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7651                        Ok(SocketRequest::SetIpMulticastTtl {
7652                            value: req.value,
7653
7654                            responder: SocketSetIpMulticastTtlResponder {
7655                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7656                                tx_id: header.tx_id,
7657                            },
7658                        })
7659                    }
7660                    0x4665cd378f39e1a => {
7661                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7662                        let mut req = fidl::new_empty!(
7663                            fidl::encoding::EmptyPayload,
7664                            fidl::encoding::DefaultFuchsiaResourceDialect
7665                        );
7666                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7667                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7668                        Ok(SocketRequest::GetIpMulticastTtl {
7669                            responder: SocketGetIpMulticastTtlResponder {
7670                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7671                                tx_id: header.tx_id,
7672                            },
7673                        })
7674                    }
7675                    0x20c55c11f00943ea => {
7676                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7677                        let mut req = fidl::new_empty!(fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastLoopbackRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
7678                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpMulticastLoopbackRequest>(&header, _body_bytes, handles, &mut req)?;
7679                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7680                        Ok(SocketRequest::SetIpMulticastLoopback {
7681                            value: req.value,
7682
7683                            responder: SocketSetIpMulticastLoopbackResponder {
7684                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7685                                tx_id: header.tx_id,
7686                            },
7687                        })
7688                    }
7689                    0x3b6b26ff558298f2 => {
7690                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7691                        let mut req = fidl::new_empty!(
7692                            fidl::encoding::EmptyPayload,
7693                            fidl::encoding::DefaultFuchsiaResourceDialect
7694                        );
7695                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7696                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7697                        Ok(SocketRequest::GetIpMulticastLoopback {
7698                            responder: SocketGetIpMulticastLoopbackResponder {
7699                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7700                                tx_id: header.tx_id,
7701                            },
7702                        })
7703                    }
7704                    0x76bc7df115a3b4d0 => {
7705                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7706                        let mut req = fidl::new_empty!(
7707                            fidl_fuchsia_posix_socket::BaseNetworkSocketAddIpMembershipRequest,
7708                            fidl::encoding::DefaultFuchsiaResourceDialect
7709                        );
7710                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketAddIpMembershipRequest>(&header, _body_bytes, handles, &mut req)?;
7711                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7712                        Ok(SocketRequest::AddIpMembership {
7713                            membership: req.membership,
7714
7715                            responder: SocketAddIpMembershipResponder {
7716                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7717                                tx_id: header.tx_id,
7718                            },
7719                        })
7720                    }
7721                    0x2888f3099188d03 => {
7722                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7723                        let mut req = fidl::new_empty!(
7724                            fidl_fuchsia_posix_socket::BaseNetworkSocketDropIpMembershipRequest,
7725                            fidl::encoding::DefaultFuchsiaResourceDialect
7726                        );
7727                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketDropIpMembershipRequest>(&header, _body_bytes, handles, &mut req)?;
7728                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7729                        Ok(SocketRequest::DropIpMembership {
7730                            membership: req.membership,
7731
7732                            responder: SocketDropIpMembershipResponder {
7733                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7734                                tx_id: header.tx_id,
7735                            },
7736                        })
7737                    }
7738                    0x1ae532b0c066e3a0 => {
7739                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7740                        let mut req = fidl::new_empty!(
7741                            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTransparentRequest,
7742                            fidl::encoding::DefaultFuchsiaResourceDialect
7743                        );
7744                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpTransparentRequest>(&header, _body_bytes, handles, &mut req)?;
7745                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7746                        Ok(SocketRequest::SetIpTransparent {
7747                            value: req.value,
7748
7749                            responder: SocketSetIpTransparentResponder {
7750                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7751                                tx_id: header.tx_id,
7752                            },
7753                        })
7754                    }
7755                    0x51d43695962ebfb5 => {
7756                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7757                        let mut req = fidl::new_empty!(
7758                            fidl::encoding::EmptyPayload,
7759                            fidl::encoding::DefaultFuchsiaResourceDialect
7760                        );
7761                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7762                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7763                        Ok(SocketRequest::GetIpTransparent {
7764                            responder: SocketGetIpTransparentResponder {
7765                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7766                                tx_id: header.tx_id,
7767                            },
7768                        })
7769                    }
7770                    0x4722b4ce52f7840 => {
7771                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7772                        let mut req = fidl::new_empty!(fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
7773                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest>(&header, _body_bytes, handles, &mut req)?;
7774                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7775                        Ok(SocketRequest::SetIpReceiveOriginalDestinationAddress {
7776                            value: req.value,
7777
7778                            responder: SocketSetIpReceiveOriginalDestinationAddressResponder {
7779                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7780                                tx_id: header.tx_id,
7781                            },
7782                        })
7783                    }
7784                    0x2a0e7dc5d6bfdfe9 => {
7785                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7786                        let mut req = fidl::new_empty!(
7787                            fidl::encoding::EmptyPayload,
7788                            fidl::encoding::DefaultFuchsiaResourceDialect
7789                        );
7790                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7791                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7792                        Ok(SocketRequest::GetIpReceiveOriginalDestinationAddress {
7793                            responder: SocketGetIpReceiveOriginalDestinationAddressResponder {
7794                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7795                                tx_id: header.tx_id,
7796                            },
7797                        })
7798                    }
7799                    0x7c94727acb4ea4b3 => {
7800                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7801                        let mut req = fidl::new_empty!(
7802                            fidl_fuchsia_posix_socket::BaseNetworkSocketAddIpv6MembershipRequest,
7803                            fidl::encoding::DefaultFuchsiaResourceDialect
7804                        );
7805                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketAddIpv6MembershipRequest>(&header, _body_bytes, handles, &mut req)?;
7806                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7807                        Ok(SocketRequest::AddIpv6Membership {
7808                            membership: req.membership,
7809
7810                            responder: SocketAddIpv6MembershipResponder {
7811                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7812                                tx_id: header.tx_id,
7813                            },
7814                        })
7815                    }
7816                    0x42104c70ccaba304 => {
7817                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7818                        let mut req = fidl::new_empty!(
7819                            fidl_fuchsia_posix_socket::BaseNetworkSocketDropIpv6MembershipRequest,
7820                            fidl::encoding::DefaultFuchsiaResourceDialect
7821                        );
7822                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketDropIpv6MembershipRequest>(&header, _body_bytes, handles, &mut req)?;
7823                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7824                        Ok(SocketRequest::DropIpv6Membership {
7825                            membership: req.membership,
7826
7827                            responder: SocketDropIpv6MembershipResponder {
7828                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7829                                tx_id: header.tx_id,
7830                            },
7831                        })
7832                    }
7833                    0x135f76db3774ab3b => {
7834                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7835                        let mut req = fidl::new_empty!(fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastInterfaceRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
7836                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastInterfaceRequest>(&header, _body_bytes, handles, &mut req)?;
7837                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7838                        Ok(SocketRequest::SetIpv6MulticastInterface {
7839                            value: req.value,
7840
7841                            responder: SocketSetIpv6MulticastInterfaceResponder {
7842                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7843                                tx_id: header.tx_id,
7844                            },
7845                        })
7846                    }
7847                    0x1f26fcdd348f1882 => {
7848                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7849                        let mut req = fidl::new_empty!(
7850                            fidl::encoding::EmptyPayload,
7851                            fidl::encoding::DefaultFuchsiaResourceDialect
7852                        );
7853                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7854                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7855                        Ok(SocketRequest::GetIpv6MulticastInterface {
7856                            responder: SocketGetIpv6MulticastInterfaceResponder {
7857                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7858                                tx_id: header.tx_id,
7859                            },
7860                        })
7861                    }
7862                    0x157d51e98f462859 => {
7863                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7864                        let mut req = fidl::new_empty!(
7865                            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6UnicastHopsRequest,
7866                            fidl::encoding::DefaultFuchsiaResourceDialect
7867                        );
7868                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6UnicastHopsRequest>(&header, _body_bytes, handles, &mut req)?;
7869                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7870                        Ok(SocketRequest::SetIpv6UnicastHops {
7871                            value: req.value,
7872
7873                            responder: SocketSetIpv6UnicastHopsResponder {
7874                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7875                                tx_id: header.tx_id,
7876                            },
7877                        })
7878                    }
7879                    0x21f4641cad8bd8d2 => {
7880                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7881                        let mut req = fidl::new_empty!(
7882                            fidl::encoding::EmptyPayload,
7883                            fidl::encoding::DefaultFuchsiaResourceDialect
7884                        );
7885                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7886                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7887                        Ok(SocketRequest::GetIpv6UnicastHops {
7888                            responder: SocketGetIpv6UnicastHopsResponder {
7889                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7890                                tx_id: header.tx_id,
7891                            },
7892                        })
7893                    }
7894                    0x5c24808ed2e84a1e => {
7895                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7896                        let mut req = fidl::new_empty!(fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceiveHopLimitRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
7897                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceiveHopLimitRequest>(&header, _body_bytes, handles, &mut req)?;
7898                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7899                        Ok(SocketRequest::SetIpv6ReceiveHopLimit {
7900                            value: req.value,
7901
7902                            responder: SocketSetIpv6ReceiveHopLimitResponder {
7903                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7904                                tx_id: header.tx_id,
7905                            },
7906                        })
7907                    }
7908                    0x341e06689885b4c0 => {
7909                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7910                        let mut req = fidl::new_empty!(
7911                            fidl::encoding::EmptyPayload,
7912                            fidl::encoding::DefaultFuchsiaResourceDialect
7913                        );
7914                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7915                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7916                        Ok(SocketRequest::GetIpv6ReceiveHopLimit {
7917                            responder: SocketGetIpv6ReceiveHopLimitResponder {
7918                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7919                                tx_id: header.tx_id,
7920                            },
7921                        })
7922                    }
7923                    0x25b9cd4d181f82c1 => {
7924                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7925                        let mut req = fidl::new_empty!(
7926                            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastHopsRequest,
7927                            fidl::encoding::DefaultFuchsiaResourceDialect
7928                        );
7929                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastHopsRequest>(&header, _body_bytes, handles, &mut req)?;
7930                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7931                        Ok(SocketRequest::SetIpv6MulticastHops {
7932                            value: req.value,
7933
7934                            responder: SocketSetIpv6MulticastHopsResponder {
7935                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7936                                tx_id: header.tx_id,
7937                            },
7938                        })
7939                    }
7940                    0x52916948a365012a => {
7941                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7942                        let mut req = fidl::new_empty!(
7943                            fidl::encoding::EmptyPayload,
7944                            fidl::encoding::DefaultFuchsiaResourceDialect
7945                        );
7946                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7947                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7948                        Ok(SocketRequest::GetIpv6MulticastHops {
7949                            responder: SocketGetIpv6MulticastHopsResponder {
7950                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7951                                tx_id: header.tx_id,
7952                            },
7953                        })
7954                    }
7955                    0x55701c409ff41b40 => {
7956                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7957                        let mut req = fidl::new_empty!(fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastLoopbackRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
7958                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6MulticastLoopbackRequest>(&header, _body_bytes, handles, &mut req)?;
7959                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7960                        Ok(SocketRequest::SetIpv6MulticastLoopback {
7961                            value: req.value,
7962
7963                            responder: SocketSetIpv6MulticastLoopbackResponder {
7964                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7965                                tx_id: header.tx_id,
7966                            },
7967                        })
7968                    }
7969                    0x4415b701fde319c3 => {
7970                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7971                        let mut req = fidl::new_empty!(
7972                            fidl::encoding::EmptyPayload,
7973                            fidl::encoding::DefaultFuchsiaResourceDialect
7974                        );
7975                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
7976                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7977                        Ok(SocketRequest::GetIpv6MulticastLoopback {
7978                            responder: SocketGetIpv6MulticastLoopbackResponder {
7979                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7980                                tx_id: header.tx_id,
7981                            },
7982                        })
7983                    }
7984                    0x4873f1364758cbba => {
7985                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
7986                        let mut req = fidl::new_empty!(
7987                            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6OnlyRequest,
7988                            fidl::encoding::DefaultFuchsiaResourceDialect
7989                        );
7990                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6OnlyRequest>(&header, _body_bytes, handles, &mut req)?;
7991                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
7992                        Ok(SocketRequest::SetIpv6Only {
7993                            value: req.value,
7994
7995                            responder: SocketSetIpv6OnlyResponder {
7996                                control_handle: std::mem::ManuallyDrop::new(control_handle),
7997                                tx_id: header.tx_id,
7998                            },
7999                        })
8000                    }
8001                    0x4aa3340a1a26b89c => {
8002                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
8003                        let mut req = fidl::new_empty!(
8004                            fidl::encoding::EmptyPayload,
8005                            fidl::encoding::DefaultFuchsiaResourceDialect
8006                        );
8007                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
8008                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
8009                        Ok(SocketRequest::GetIpv6Only {
8010                            responder: SocketGetIpv6OnlyResponder {
8011                                control_handle: std::mem::ManuallyDrop::new(control_handle),
8012                                tx_id: header.tx_id,
8013                            },
8014                        })
8015                    }
8016                    0x58f07c8788d099a0 => {
8017                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
8018                        let mut req = fidl::new_empty!(fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
8019                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest>(&header, _body_bytes, handles, &mut req)?;
8020                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
8021                        Ok(SocketRequest::SetIpv6ReceiveTrafficClass {
8022                            value: req.value,
8023
8024                            responder: SocketSetIpv6ReceiveTrafficClassResponder {
8025                                control_handle: std::mem::ManuallyDrop::new(control_handle),
8026                                tx_id: header.tx_id,
8027                            },
8028                        })
8029                    }
8030                    0x2e334df1da553ffa => {
8031                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
8032                        let mut req = fidl::new_empty!(
8033                            fidl::encoding::EmptyPayload,
8034                            fidl::encoding::DefaultFuchsiaResourceDialect
8035                        );
8036                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
8037                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
8038                        Ok(SocketRequest::GetIpv6ReceiveTrafficClass {
8039                            responder: SocketGetIpv6ReceiveTrafficClassResponder {
8040                                control_handle: std::mem::ManuallyDrop::new(control_handle),
8041                                tx_id: header.tx_id,
8042                            },
8043                        })
8044                    }
8045                    0x6af077800c5a0b4f => {
8046                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
8047                        let mut req = fidl::new_empty!(
8048                            fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6TrafficClassRequest,
8049                            fidl::encoding::DefaultFuchsiaResourceDialect
8050                        );
8051                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6TrafficClassRequest>(&header, _body_bytes, handles, &mut req)?;
8052                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
8053                        Ok(SocketRequest::SetIpv6TrafficClass {
8054                            value: req.value,
8055
8056                            responder: SocketSetIpv6TrafficClassResponder {
8057                                control_handle: std::mem::ManuallyDrop::new(control_handle),
8058                                tx_id: header.tx_id,
8059                            },
8060                        })
8061                    }
8062                    0x6baf6eed8fc2f04 => {
8063                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
8064                        let mut req = fidl::new_empty!(
8065                            fidl::encoding::EmptyPayload,
8066                            fidl::encoding::DefaultFuchsiaResourceDialect
8067                        );
8068                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
8069                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
8070                        Ok(SocketRequest::GetIpv6TrafficClass {
8071                            responder: SocketGetIpv6TrafficClassResponder {
8072                                control_handle: std::mem::ManuallyDrop::new(control_handle),
8073                                tx_id: header.tx_id,
8074                            },
8075                        })
8076                    }
8077                    0x19259775b1a92768 => {
8078                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
8079                        let mut req = fidl::new_empty!(fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceivePacketInfoRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
8080                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_posix_socket::BaseNetworkSocketSetIpv6ReceivePacketInfoRequest>(&header, _body_bytes, handles, &mut req)?;
8081                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
8082                        Ok(SocketRequest::SetIpv6ReceivePacketInfo {
8083                            value: req.value,
8084
8085                            responder: SocketSetIpv6ReceivePacketInfoResponder {
8086                                control_handle: std::mem::ManuallyDrop::new(control_handle),
8087                                tx_id: header.tx_id,
8088                            },
8089                        })
8090                    }
8091                    0x7acd4a2775baec75 => {
8092                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
8093                        let mut req = fidl::new_empty!(
8094                            fidl::encoding::EmptyPayload,
8095                            fidl::encoding::DefaultFuchsiaResourceDialect
8096                        );
8097                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
8098                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
8099                        Ok(SocketRequest::GetIpv6ReceivePacketInfo {
8100                            responder: SocketGetIpv6ReceivePacketInfoResponder {
8101                                control_handle: std::mem::ManuallyDrop::new(control_handle),
8102                                tx_id: header.tx_id,
8103                            },
8104                        })
8105                    }
8106                    0x38bf28f0dafdbac0 => {
8107                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
8108                        let mut req = fidl::new_empty!(
8109                            fidl::encoding::EmptyPayload,
8110                            fidl::encoding::DefaultFuchsiaResourceDialect
8111                        );
8112                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
8113                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
8114                        Ok(SocketRequest::GetOriginalDestination {
8115                            responder: SocketGetOriginalDestinationResponder {
8116                                control_handle: std::mem::ManuallyDrop::new(control_handle),
8117                                tx_id: header.tx_id,
8118                            },
8119                        })
8120                    }
8121                    0x335706eccf54a135 => {
8122                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
8123                        let mut req = fidl::new_empty!(
8124                            fidl::encoding::EmptyPayload,
8125                            fidl::encoding::DefaultFuchsiaResourceDialect
8126                        );
8127                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
8128                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
8129                        Ok(SocketRequest::Describe {
8130                            responder: SocketDescribeResponder {
8131                                control_handle: std::mem::ManuallyDrop::new(control_handle),
8132                                tx_id: header.tx_id,
8133                            },
8134                        })
8135                    }
8136                    0x1dfb695351d3aa1d => {
8137                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
8138                        let mut req = fidl::new_empty!(
8139                            SocketRecvMsgRequest,
8140                            fidl::encoding::DefaultFuchsiaResourceDialect
8141                        );
8142                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SocketRecvMsgRequest>(&header, _body_bytes, handles, &mut req)?;
8143                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
8144                        Ok(SocketRequest::RecvMsg {
8145                            want_addr: req.want_addr,
8146                            data_len: req.data_len,
8147                            want_control: req.want_control,
8148                            flags: req.flags,
8149
8150                            responder: SocketRecvMsgResponder {
8151                                control_handle: std::mem::ManuallyDrop::new(control_handle),
8152                                tx_id: header.tx_id,
8153                            },
8154                        })
8155                    }
8156                    0x2cf1eac9a7fc8958 => {
8157                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
8158                        let mut req = fidl::new_empty!(
8159                            SocketSendMsgRequest,
8160                            fidl::encoding::DefaultFuchsiaResourceDialect
8161                        );
8162                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SocketSendMsgRequest>(&header, _body_bytes, handles, &mut req)?;
8163                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
8164                        Ok(SocketRequest::SendMsg {
8165                            addr: req.addr,
8166                            data: req.data,
8167                            control: req.control,
8168                            flags: req.flags,
8169
8170                            responder: SocketSendMsgResponder {
8171                                control_handle: std::mem::ManuallyDrop::new(control_handle),
8172                                tx_id: header.tx_id,
8173                            },
8174                        })
8175                    }
8176                    0x39676f75aec339ba => {
8177                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
8178                        let mut req = fidl::new_empty!(
8179                            fidl::encoding::EmptyPayload,
8180                            fidl::encoding::DefaultFuchsiaResourceDialect
8181                        );
8182                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
8183                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
8184                        Ok(SocketRequest::GetInfo {
8185                            responder: SocketGetInfoResponder {
8186                                control_handle: std::mem::ManuallyDrop::new(control_handle),
8187                                tx_id: header.tx_id,
8188                            },
8189                        })
8190                    }
8191                    0x5d06a606d95e8f3 => {
8192                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
8193                        let mut req = fidl::new_empty!(
8194                            SocketSetIpHeaderIncludedRequest,
8195                            fidl::encoding::DefaultFuchsiaResourceDialect
8196                        );
8197                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SocketSetIpHeaderIncludedRequest>(&header, _body_bytes, handles, &mut req)?;
8198                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
8199                        Ok(SocketRequest::SetIpHeaderIncluded {
8200                            value: req.value,
8201
8202                            responder: SocketSetIpHeaderIncludedResponder {
8203                                control_handle: std::mem::ManuallyDrop::new(control_handle),
8204                                tx_id: header.tx_id,
8205                            },
8206                        })
8207                    }
8208                    0x76125ad1f4d175f6 => {
8209                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
8210                        let mut req = fidl::new_empty!(
8211                            fidl::encoding::EmptyPayload,
8212                            fidl::encoding::DefaultFuchsiaResourceDialect
8213                        );
8214                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
8215                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
8216                        Ok(SocketRequest::GetIpHeaderIncluded {
8217                            responder: SocketGetIpHeaderIncludedResponder {
8218                                control_handle: std::mem::ManuallyDrop::new(control_handle),
8219                                tx_id: header.tx_id,
8220                            },
8221                        })
8222                    }
8223                    0x4ebea92a43ae68a9 => {
8224                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
8225                        let mut req = fidl::new_empty!(
8226                            SocketSetIcmpv6FilterRequest,
8227                            fidl::encoding::DefaultFuchsiaResourceDialect
8228                        );
8229                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SocketSetIcmpv6FilterRequest>(&header, _body_bytes, handles, &mut req)?;
8230                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
8231                        Ok(SocketRequest::SetIcmpv6Filter {
8232                            filter: req.filter,
8233
8234                            responder: SocketSetIcmpv6FilterResponder {
8235                                control_handle: std::mem::ManuallyDrop::new(control_handle),
8236                                tx_id: header.tx_id,
8237                            },
8238                        })
8239                    }
8240                    0x43bd4f3bc0970ace => {
8241                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
8242                        let mut req = fidl::new_empty!(
8243                            fidl::encoding::EmptyPayload,
8244                            fidl::encoding::DefaultFuchsiaResourceDialect
8245                        );
8246                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
8247                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
8248                        Ok(SocketRequest::GetIcmpv6Filter {
8249                            responder: SocketGetIcmpv6FilterResponder {
8250                                control_handle: std::mem::ManuallyDrop::new(control_handle),
8251                                tx_id: header.tx_id,
8252                            },
8253                        })
8254                    }
8255                    0x18b7809577199cb4 => {
8256                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
8257                        let mut req = fidl::new_empty!(
8258                            SocketSetIpv6ChecksumRequest,
8259                            fidl::encoding::DefaultFuchsiaResourceDialect
8260                        );
8261                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SocketSetIpv6ChecksumRequest>(&header, _body_bytes, handles, &mut req)?;
8262                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
8263                        Ok(SocketRequest::SetIpv6Checksum {
8264                            config: req.config,
8265
8266                            responder: SocketSetIpv6ChecksumResponder {
8267                                control_handle: std::mem::ManuallyDrop::new(control_handle),
8268                                tx_id: header.tx_id,
8269                            },
8270                        })
8271                    }
8272                    0x1847bf5b2d263dd => {
8273                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
8274                        let mut req = fidl::new_empty!(
8275                            fidl::encoding::EmptyPayload,
8276                            fidl::encoding::DefaultFuchsiaResourceDialect
8277                        );
8278                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
8279                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
8280                        Ok(SocketRequest::GetIpv6Checksum {
8281                            responder: SocketGetIpv6ChecksumResponder {
8282                                control_handle: std::mem::ManuallyDrop::new(control_handle),
8283                                tx_id: header.tx_id,
8284                            },
8285                        })
8286                    }
8287                    _ => Err(fidl::Error::UnknownOrdinal {
8288                        ordinal: header.ordinal,
8289                        protocol_name:
8290                            <SocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
8291                    }),
8292                }))
8293            },
8294        )
8295    }
8296}
8297
8298/// A raw network socket.
8299///
8300/// Once a socket has been retrieved from a provider, this interface is then
8301/// used to further configure and use the socket. This interface is essentially
8302/// POSIX.
8303///
8304/// All methods on this type are nonblocking; their exact behaviors match their
8305/// Linux counterparts.
8306///
8307/// *Warning:* This protocol is not yet ready for direct use by clients.
8308/// Instead, clients should use the BSD sockets API to interact with sockets.
8309/// We plan to change this protocol substantially and clients that couple
8310/// directly to this protocol will make those changes more difficult.
8311#[derive(Debug)]
8312pub enum SocketRequest {
8313    Clone {
8314        request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
8315        control_handle: SocketControlHandle,
8316    },
8317    /// Terminates the connection.
8318    ///
8319    /// After calling `Close`, the client must not send any other requests.
8320    ///
8321    /// Servers, after sending the status response, should close the connection
8322    /// regardless of status and without sending an epitaph.
8323    ///
8324    /// Closing the client end of the channel should be semantically equivalent
8325    /// to calling `Close` without knowing when the close has completed or its
8326    /// status.
8327    Close {
8328        responder: SocketCloseResponder,
8329    },
8330    Query {
8331        responder: SocketQueryResponder,
8332    },
8333    /// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
8334    SetReuseAddress {
8335        value: bool,
8336        responder: SocketSetReuseAddressResponder,
8337    },
8338    /// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
8339    GetReuseAddress {
8340        responder: SocketGetReuseAddressResponder,
8341    },
8342    /// Get `SOL_SOCKET` -> `SO_ERROR`.
8343    /// Returns the last error if there is an error set on the socket.
8344    GetError {
8345        responder: SocketGetErrorResponder,
8346    },
8347    /// Set `SOL_SOCKET` -> `SO_BROADCAST`.
8348    SetBroadcast {
8349        value: bool,
8350        responder: SocketSetBroadcastResponder,
8351    },
8352    /// Get `SOL_SOCKET` -> `SO_BROADCAST`.
8353    GetBroadcast {
8354        responder: SocketGetBroadcastResponder,
8355    },
8356    /// Set `SOL_SOCKET` -> `SO_SNDBUF`.
8357    SetSendBuffer {
8358        value_bytes: u64,
8359        responder: SocketSetSendBufferResponder,
8360    },
8361    /// Get `SOL_SOCKET` -> `SO_SNDBUF`.
8362    GetSendBuffer {
8363        responder: SocketGetSendBufferResponder,
8364    },
8365    /// Set `SOL_SOCKET` -> `SO_RCVBUF`.
8366    SetReceiveBuffer {
8367        value_bytes: u64,
8368        responder: SocketSetReceiveBufferResponder,
8369    },
8370    /// Get `SOL_SOCKET` -> `SO_RCVBUF`.
8371    GetReceiveBuffer {
8372        responder: SocketGetReceiveBufferResponder,
8373    },
8374    /// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
8375    SetKeepAlive {
8376        value: bool,
8377        responder: SocketSetKeepAliveResponder,
8378    },
8379    /// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
8380    GetKeepAlive {
8381        responder: SocketGetKeepAliveResponder,
8382    },
8383    /// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
8384    SetOutOfBandInline {
8385        value: bool,
8386        responder: SocketSetOutOfBandInlineResponder,
8387    },
8388    /// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
8389    GetOutOfBandInline {
8390        responder: SocketGetOutOfBandInlineResponder,
8391    },
8392    /// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
8393    SetNoCheck {
8394        value: bool,
8395        responder: SocketSetNoCheckResponder,
8396    },
8397    /// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
8398    GetNoCheck {
8399        responder: SocketGetNoCheckResponder,
8400    },
8401    /// Set `SOL_SOCKET` -> `SO_LINGER`.
8402    SetLinger {
8403        linger: bool,
8404        length_secs: u32,
8405        responder: SocketSetLingerResponder,
8406    },
8407    /// Get `SOL_SOCKET` -> `SO_LINGER`.
8408    GetLinger {
8409        responder: SocketGetLingerResponder,
8410    },
8411    /// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
8412    SetReusePort {
8413        value: bool,
8414        responder: SocketSetReusePortResponder,
8415    },
8416    /// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
8417    GetReusePort {
8418        responder: SocketGetReusePortResponder,
8419    },
8420    /// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
8421    GetAcceptConn {
8422        responder: SocketGetAcceptConnResponder,
8423    },
8424    /// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
8425    SetBindToDevice {
8426        value: String,
8427        responder: SocketSetBindToDeviceResponder,
8428    },
8429    /// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
8430    GetBindToDevice {
8431        responder: SocketGetBindToDeviceResponder,
8432    },
8433    /// Set `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
8434    /// If `value` is 0, this clears the bound interface.
8435    SetBindToInterfaceIndex {
8436        value: u64,
8437        responder: SocketSetBindToInterfaceIndexResponder,
8438    },
8439    /// Get `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
8440    GetBindToInterfaceIndex {
8441        responder: SocketGetBindToInterfaceIndexResponder,
8442    },
8443    /// Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
8444    SetTimestamp {
8445        value: fidl_fuchsia_posix_socket::TimestampOption,
8446        responder: SocketSetTimestampResponder,
8447    },
8448    /// Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
8449    GetTimestamp {
8450        responder: SocketGetTimestampResponder,
8451    },
8452    /// Like setting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
8453    /// unlike the standard SO_MARK, this API has multiple mark domains and each
8454    /// mark can be set independently in each domain.
8455    SetMark {
8456        domain: fidl_fuchsia_net::MarkDomain,
8457        mark: fidl_fuchsia_posix_socket::OptionalUint32,
8458        responder: SocketSetMarkResponder,
8459    },
8460    /// Like getting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
8461    /// unlike the standard SO_MARK, this API has multiple mark domains and each
8462    /// mark can be retrieved independently in each domain.
8463    GetMark {
8464        domain: fidl_fuchsia_net::MarkDomain,
8465        responder: SocketGetMarkResponder,
8466    },
8467    /// Get `SOL_SOCKET` -> `SO_COOKIE`.
8468    GetCookie {
8469        responder: SocketGetCookieResponder,
8470    },
8471    /// Sets the local address used for the socket.
8472    Bind {
8473        addr: fidl_fuchsia_net::SocketAddress,
8474        responder: SocketBindResponder,
8475    },
8476    /// Initiates a connection to a remote address.
8477    Connect {
8478        addr: fidl_fuchsia_net::SocketAddress,
8479        responder: SocketConnectResponder,
8480    },
8481    /// Clears connection information from this socket.
8482    Disconnect {
8483        responder: SocketDisconnectResponder,
8484    },
8485    /// Retrieves the local socket address.
8486    GetSockName {
8487        responder: SocketGetSockNameResponder,
8488    },
8489    /// Retrieves the remote socket address.
8490    GetPeerName {
8491        responder: SocketGetPeerNameResponder,
8492    },
8493    /// Shuts down part of the socket.
8494    Shutdown {
8495        mode: fidl_fuchsia_posix_socket::ShutdownMode,
8496        responder: SocketShutdownResponder,
8497    },
8498    /// Set `SOL_IP` -> `IP_TOS`.
8499    SetIpTypeOfService {
8500        value: u8,
8501        responder: SocketSetIpTypeOfServiceResponder,
8502    },
8503    /// Get `SOL_IP` -> `IP_TOS`.
8504    GetIpTypeOfService {
8505        responder: SocketGetIpTypeOfServiceResponder,
8506    },
8507    /// Set `SOL_IP` -> `IP_TTL`.
8508    SetIpTtl {
8509        value: fidl_fuchsia_posix_socket::OptionalUint8,
8510        responder: SocketSetIpTtlResponder,
8511    },
8512    /// Get `SOL_IP` -> `IP_TTL`.
8513    GetIpTtl {
8514        responder: SocketGetIpTtlResponder,
8515    },
8516    /// Set `SOL_IP` -> `IP_PKTINFO`.
8517    SetIpPacketInfo {
8518        value: bool,
8519        responder: SocketSetIpPacketInfoResponder,
8520    },
8521    /// Get `SOL_IP` -> `IP_PKTINFO`.
8522    GetIpPacketInfo {
8523        responder: SocketGetIpPacketInfoResponder,
8524    },
8525    /// Set `SOL_IP` -> `IP_RECVTOS`.
8526    SetIpReceiveTypeOfService {
8527        value: bool,
8528        responder: SocketSetIpReceiveTypeOfServiceResponder,
8529    },
8530    /// Get `SOL_IP` -> `IP_RECVTOS`.
8531    GetIpReceiveTypeOfService {
8532        responder: SocketGetIpReceiveTypeOfServiceResponder,
8533    },
8534    /// Set `SOL_IP` -> `IP_RECVTTL`.
8535    SetIpReceiveTtl {
8536        value: bool,
8537        responder: SocketSetIpReceiveTtlResponder,
8538    },
8539    /// Get `SOL_IP` -> `IP_RECVTTL`.
8540    GetIpReceiveTtl {
8541        responder: SocketGetIpReceiveTtlResponder,
8542    },
8543    /// Set `SOL_IP` -> `IP_MULTICAST_IF`.
8544    SetIpMulticastInterface {
8545        iface: u64,
8546        address: fidl_fuchsia_net::Ipv4Address,
8547        responder: SocketSetIpMulticastInterfaceResponder,
8548    },
8549    /// Get `SOL_IP` -> `IP_MULTICAST_IF`.
8550    GetIpMulticastInterface {
8551        responder: SocketGetIpMulticastInterfaceResponder,
8552    },
8553    /// Set `SOL_IP` -> `IP_MULTICAST_TTL`.
8554    SetIpMulticastTtl {
8555        value: fidl_fuchsia_posix_socket::OptionalUint8,
8556        responder: SocketSetIpMulticastTtlResponder,
8557    },
8558    /// Get `SOL_IP` -> `IP_MULTICAST_TTL`.
8559    GetIpMulticastTtl {
8560        responder: SocketGetIpMulticastTtlResponder,
8561    },
8562    /// Set `SOL_IP` -> `IP_MULTICAST_LOOP`.
8563    SetIpMulticastLoopback {
8564        value: bool,
8565        responder: SocketSetIpMulticastLoopbackResponder,
8566    },
8567    /// Get `SOL_IP` -> `IP_MULTICAST_LOOP`.
8568    GetIpMulticastLoopback {
8569        responder: SocketGetIpMulticastLoopbackResponder,
8570    },
8571    /// Set `SOL_IP` -> `IP_ADD_MEMBERSHIP`
8572    AddIpMembership {
8573        membership: fidl_fuchsia_posix_socket::IpMulticastMembership,
8574        responder: SocketAddIpMembershipResponder,
8575    },
8576    /// Set `SOL_IP` -> `IP_DROP_MEMBERSHIP`
8577    DropIpMembership {
8578        membership: fidl_fuchsia_posix_socket::IpMulticastMembership,
8579        responder: SocketDropIpMembershipResponder,
8580    },
8581    /// Set `SOL_IP` -> `IP_TRANSPARENT`
8582    SetIpTransparent {
8583        value: bool,
8584        responder: SocketSetIpTransparentResponder,
8585    },
8586    /// Get `SOL_IP` -> `IP_TRANSPARENT`
8587    GetIpTransparent {
8588        responder: SocketGetIpTransparentResponder,
8589    },
8590    /// Set `SOL_IP` -> `IP_RECVORIGDSTADDR`
8591    SetIpReceiveOriginalDestinationAddress {
8592        value: bool,
8593        responder: SocketSetIpReceiveOriginalDestinationAddressResponder,
8594    },
8595    /// Get `SOL_IP` -> `IP_RECVORIGDSTADDR`
8596    GetIpReceiveOriginalDestinationAddress {
8597        responder: SocketGetIpReceiveOriginalDestinationAddressResponder,
8598    },
8599    /// Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`.
8600    AddIpv6Membership {
8601        membership: fidl_fuchsia_posix_socket::Ipv6MulticastMembership,
8602        responder: SocketAddIpv6MembershipResponder,
8603    },
8604    /// Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`.
8605    DropIpv6Membership {
8606        membership: fidl_fuchsia_posix_socket::Ipv6MulticastMembership,
8607        responder: SocketDropIpv6MembershipResponder,
8608    },
8609    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
8610    SetIpv6MulticastInterface {
8611        value: u64,
8612        responder: SocketSetIpv6MulticastInterfaceResponder,
8613    },
8614    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
8615    GetIpv6MulticastInterface {
8616        responder: SocketGetIpv6MulticastInterfaceResponder,
8617    },
8618    /// Set `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
8619    SetIpv6UnicastHops {
8620        value: fidl_fuchsia_posix_socket::OptionalUint8,
8621        responder: SocketSetIpv6UnicastHopsResponder,
8622    },
8623    /// Get `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
8624    GetIpv6UnicastHops {
8625        responder: SocketGetIpv6UnicastHopsResponder,
8626    },
8627    /// Set `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
8628    SetIpv6ReceiveHopLimit {
8629        value: bool,
8630        responder: SocketSetIpv6ReceiveHopLimitResponder,
8631    },
8632    /// Get `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
8633    GetIpv6ReceiveHopLimit {
8634        responder: SocketGetIpv6ReceiveHopLimitResponder,
8635    },
8636    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
8637    SetIpv6MulticastHops {
8638        value: fidl_fuchsia_posix_socket::OptionalUint8,
8639        responder: SocketSetIpv6MulticastHopsResponder,
8640    },
8641    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
8642    GetIpv6MulticastHops {
8643        responder: SocketGetIpv6MulticastHopsResponder,
8644    },
8645    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
8646    SetIpv6MulticastLoopback {
8647        value: bool,
8648        responder: SocketSetIpv6MulticastLoopbackResponder,
8649    },
8650    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
8651    GetIpv6MulticastLoopback {
8652        responder: SocketGetIpv6MulticastLoopbackResponder,
8653    },
8654    /// Set `SOL_IPV6` -> `IPV6_V6ONLY`.
8655    SetIpv6Only {
8656        value: bool,
8657        responder: SocketSetIpv6OnlyResponder,
8658    },
8659    /// Get `SOL_IPV6` -> `IPV6_V6ONLY`.
8660    GetIpv6Only {
8661        responder: SocketGetIpv6OnlyResponder,
8662    },
8663    /// Set `SOL_IPV6` -> `IPV6_RECVTCLASS`.
8664    SetIpv6ReceiveTrafficClass {
8665        value: bool,
8666        responder: SocketSetIpv6ReceiveTrafficClassResponder,
8667    },
8668    /// Get `SOL_IPV6` -> `IPV6_RECVTCLASS`.
8669    GetIpv6ReceiveTrafficClass {
8670        responder: SocketGetIpv6ReceiveTrafficClassResponder,
8671    },
8672    /// Set `SOL_IPV6` -> `IPV6_TCLASS`
8673    SetIpv6TrafficClass {
8674        value: fidl_fuchsia_posix_socket::OptionalUint8,
8675        responder: SocketSetIpv6TrafficClassResponder,
8676    },
8677    /// Get `SOL_IPV6` -> `IPV6_TCLASS`.
8678    GetIpv6TrafficClass {
8679        responder: SocketGetIpv6TrafficClassResponder,
8680    },
8681    /// Set `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
8682    SetIpv6ReceivePacketInfo {
8683        value: bool,
8684        responder: SocketSetIpv6ReceivePacketInfoResponder,
8685    },
8686    /// Get `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
8687    GetIpv6ReceivePacketInfo {
8688        responder: SocketGetIpv6ReceivePacketInfoResponder,
8689    },
8690    /// Get `SOL_IP` -> `SO_ORIGINAL_DST`.
8691    GetOriginalDestination {
8692        responder: SocketGetOriginalDestinationResponder,
8693    },
8694    Describe {
8695        responder: SocketDescribeResponder,
8696    },
8697    /// Receives a message from the socket.
8698    ///
8699    /// + request `want_addr` request message's source address information to
8700    ///   be returned.
8701    /// + request `data_len` the maximum allowed length of the response data
8702    ///   buffer.
8703    /// + request `want_control` request ancillary data to be returned.
8704    /// + request `flags` flags for the receive request.
8705    /// - response `addr` the message's source address information, if
8706    ///   requested.
8707    /// - response `data` the message.
8708    /// - response `control` control messages, if requested.
8709    /// - response `truncated` indicates whether or not the returned message
8710    ///   was truncated.
8711    RecvMsg {
8712        want_addr: bool,
8713        data_len: u32,
8714        want_control: bool,
8715        flags: fidl_fuchsia_posix_socket::RecvMsgFlags,
8716        responder: SocketRecvMsgResponder,
8717    },
8718    /// Sends a message on the socket.
8719    ///
8720    /// + request `addr` the address to send the message to. If unset, will
8721    ///   send to the connected peer.
8722    /// + request `data` the message.
8723    /// + request `control` ancillary data.
8724    /// + request `flags` flags for the send request.
8725    SendMsg {
8726        addr: Option<Box<fidl_fuchsia_net::SocketAddress>>,
8727        data: Vec<u8>,
8728        control: fidl_fuchsia_posix_socket::NetworkSocketSendControlData,
8729        flags: fidl_fuchsia_posix_socket::SendMsgFlags,
8730        responder: SocketSendMsgResponder,
8731    },
8732    /// Retrieves creation information from the socket.
8733    ///
8734    /// - response `domain` the socket's associated domain.
8735    /// - response `proto` the socket's associated protocol.
8736    GetInfo {
8737        responder: SocketGetInfoResponder,
8738    },
8739    /// Set `SOL_IP` -> `IP_HDRINCL`.
8740    SetIpHeaderIncluded {
8741        value: bool,
8742        responder: SocketSetIpHeaderIncludedResponder,
8743    },
8744    /// Get `SOL_IP` -> `IP_HDRINCL`.
8745    GetIpHeaderIncluded {
8746        responder: SocketGetIpHeaderIncludedResponder,
8747    },
8748    /// Set `SOL_ICMPV6` -> `ICMP6_FILTER`.
8749    SetIcmpv6Filter {
8750        filter: Icmpv6Filter,
8751        responder: SocketSetIcmpv6FilterResponder,
8752    },
8753    /// Get `SOL_ICMPV6` -> `ICMP6_FILTER`.
8754    GetIcmpv6Filter {
8755        responder: SocketGetIcmpv6FilterResponder,
8756    },
8757    /// Set `SOL_IPV6` -> `IPV6_CHECKSUM`.
8758    SetIpv6Checksum {
8759        config: Ipv6ChecksumConfiguration,
8760        responder: SocketSetIpv6ChecksumResponder,
8761    },
8762    /// Get `SOL_IPV6` -> `IPV6_CHECKSUM`.
8763    GetIpv6Checksum {
8764        responder: SocketGetIpv6ChecksumResponder,
8765    },
8766}
8767
8768impl SocketRequest {
8769    #[allow(irrefutable_let_patterns)]
8770    pub fn into_clone(
8771        self,
8772    ) -> Option<(
8773        fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
8774        SocketControlHandle,
8775    )> {
8776        if let SocketRequest::Clone { request, control_handle } = self {
8777            Some((request, control_handle))
8778        } else {
8779            None
8780        }
8781    }
8782
8783    #[allow(irrefutable_let_patterns)]
8784    pub fn into_close(self) -> Option<(SocketCloseResponder)> {
8785        if let SocketRequest::Close { responder } = self {
8786            Some((responder))
8787        } else {
8788            None
8789        }
8790    }
8791
8792    #[allow(irrefutable_let_patterns)]
8793    pub fn into_query(self) -> Option<(SocketQueryResponder)> {
8794        if let SocketRequest::Query { responder } = self {
8795            Some((responder))
8796        } else {
8797            None
8798        }
8799    }
8800
8801    #[allow(irrefutable_let_patterns)]
8802    pub fn into_set_reuse_address(self) -> Option<(bool, SocketSetReuseAddressResponder)> {
8803        if let SocketRequest::SetReuseAddress { value, responder } = self {
8804            Some((value, responder))
8805        } else {
8806            None
8807        }
8808    }
8809
8810    #[allow(irrefutable_let_patterns)]
8811    pub fn into_get_reuse_address(self) -> Option<(SocketGetReuseAddressResponder)> {
8812        if let SocketRequest::GetReuseAddress { responder } = self {
8813            Some((responder))
8814        } else {
8815            None
8816        }
8817    }
8818
8819    #[allow(irrefutable_let_patterns)]
8820    pub fn into_get_error(self) -> Option<(SocketGetErrorResponder)> {
8821        if let SocketRequest::GetError { responder } = self {
8822            Some((responder))
8823        } else {
8824            None
8825        }
8826    }
8827
8828    #[allow(irrefutable_let_patterns)]
8829    pub fn into_set_broadcast(self) -> Option<(bool, SocketSetBroadcastResponder)> {
8830        if let SocketRequest::SetBroadcast { value, responder } = self {
8831            Some((value, responder))
8832        } else {
8833            None
8834        }
8835    }
8836
8837    #[allow(irrefutable_let_patterns)]
8838    pub fn into_get_broadcast(self) -> Option<(SocketGetBroadcastResponder)> {
8839        if let SocketRequest::GetBroadcast { responder } = self {
8840            Some((responder))
8841        } else {
8842            None
8843        }
8844    }
8845
8846    #[allow(irrefutable_let_patterns)]
8847    pub fn into_set_send_buffer(self) -> Option<(u64, SocketSetSendBufferResponder)> {
8848        if let SocketRequest::SetSendBuffer { value_bytes, responder } = self {
8849            Some((value_bytes, responder))
8850        } else {
8851            None
8852        }
8853    }
8854
8855    #[allow(irrefutable_let_patterns)]
8856    pub fn into_get_send_buffer(self) -> Option<(SocketGetSendBufferResponder)> {
8857        if let SocketRequest::GetSendBuffer { responder } = self {
8858            Some((responder))
8859        } else {
8860            None
8861        }
8862    }
8863
8864    #[allow(irrefutable_let_patterns)]
8865    pub fn into_set_receive_buffer(self) -> Option<(u64, SocketSetReceiveBufferResponder)> {
8866        if let SocketRequest::SetReceiveBuffer { value_bytes, responder } = self {
8867            Some((value_bytes, responder))
8868        } else {
8869            None
8870        }
8871    }
8872
8873    #[allow(irrefutable_let_patterns)]
8874    pub fn into_get_receive_buffer(self) -> Option<(SocketGetReceiveBufferResponder)> {
8875        if let SocketRequest::GetReceiveBuffer { responder } = self {
8876            Some((responder))
8877        } else {
8878            None
8879        }
8880    }
8881
8882    #[allow(irrefutable_let_patterns)]
8883    pub fn into_set_keep_alive(self) -> Option<(bool, SocketSetKeepAliveResponder)> {
8884        if let SocketRequest::SetKeepAlive { value, responder } = self {
8885            Some((value, responder))
8886        } else {
8887            None
8888        }
8889    }
8890
8891    #[allow(irrefutable_let_patterns)]
8892    pub fn into_get_keep_alive(self) -> Option<(SocketGetKeepAliveResponder)> {
8893        if let SocketRequest::GetKeepAlive { responder } = self {
8894            Some((responder))
8895        } else {
8896            None
8897        }
8898    }
8899
8900    #[allow(irrefutable_let_patterns)]
8901    pub fn into_set_out_of_band_inline(self) -> Option<(bool, SocketSetOutOfBandInlineResponder)> {
8902        if let SocketRequest::SetOutOfBandInline { value, responder } = self {
8903            Some((value, responder))
8904        } else {
8905            None
8906        }
8907    }
8908
8909    #[allow(irrefutable_let_patterns)]
8910    pub fn into_get_out_of_band_inline(self) -> Option<(SocketGetOutOfBandInlineResponder)> {
8911        if let SocketRequest::GetOutOfBandInline { responder } = self {
8912            Some((responder))
8913        } else {
8914            None
8915        }
8916    }
8917
8918    #[allow(irrefutable_let_patterns)]
8919    pub fn into_set_no_check(self) -> Option<(bool, SocketSetNoCheckResponder)> {
8920        if let SocketRequest::SetNoCheck { value, responder } = self {
8921            Some((value, responder))
8922        } else {
8923            None
8924        }
8925    }
8926
8927    #[allow(irrefutable_let_patterns)]
8928    pub fn into_get_no_check(self) -> Option<(SocketGetNoCheckResponder)> {
8929        if let SocketRequest::GetNoCheck { responder } = self {
8930            Some((responder))
8931        } else {
8932            None
8933        }
8934    }
8935
8936    #[allow(irrefutable_let_patterns)]
8937    pub fn into_set_linger(self) -> Option<(bool, u32, SocketSetLingerResponder)> {
8938        if let SocketRequest::SetLinger { linger, length_secs, responder } = self {
8939            Some((linger, length_secs, responder))
8940        } else {
8941            None
8942        }
8943    }
8944
8945    #[allow(irrefutable_let_patterns)]
8946    pub fn into_get_linger(self) -> Option<(SocketGetLingerResponder)> {
8947        if let SocketRequest::GetLinger { responder } = self {
8948            Some((responder))
8949        } else {
8950            None
8951        }
8952    }
8953
8954    #[allow(irrefutable_let_patterns)]
8955    pub fn into_set_reuse_port(self) -> Option<(bool, SocketSetReusePortResponder)> {
8956        if let SocketRequest::SetReusePort { value, responder } = self {
8957            Some((value, responder))
8958        } else {
8959            None
8960        }
8961    }
8962
8963    #[allow(irrefutable_let_patterns)]
8964    pub fn into_get_reuse_port(self) -> Option<(SocketGetReusePortResponder)> {
8965        if let SocketRequest::GetReusePort { responder } = self {
8966            Some((responder))
8967        } else {
8968            None
8969        }
8970    }
8971
8972    #[allow(irrefutable_let_patterns)]
8973    pub fn into_get_accept_conn(self) -> Option<(SocketGetAcceptConnResponder)> {
8974        if let SocketRequest::GetAcceptConn { responder } = self {
8975            Some((responder))
8976        } else {
8977            None
8978        }
8979    }
8980
8981    #[allow(irrefutable_let_patterns)]
8982    pub fn into_set_bind_to_device(self) -> Option<(String, SocketSetBindToDeviceResponder)> {
8983        if let SocketRequest::SetBindToDevice { value, responder } = self {
8984            Some((value, responder))
8985        } else {
8986            None
8987        }
8988    }
8989
8990    #[allow(irrefutable_let_patterns)]
8991    pub fn into_get_bind_to_device(self) -> Option<(SocketGetBindToDeviceResponder)> {
8992        if let SocketRequest::GetBindToDevice { responder } = self {
8993            Some((responder))
8994        } else {
8995            None
8996        }
8997    }
8998
8999    #[allow(irrefutable_let_patterns)]
9000    pub fn into_set_bind_to_interface_index(
9001        self,
9002    ) -> Option<(u64, SocketSetBindToInterfaceIndexResponder)> {
9003        if let SocketRequest::SetBindToInterfaceIndex { value, responder } = self {
9004            Some((value, responder))
9005        } else {
9006            None
9007        }
9008    }
9009
9010    #[allow(irrefutable_let_patterns)]
9011    pub fn into_get_bind_to_interface_index(
9012        self,
9013    ) -> Option<(SocketGetBindToInterfaceIndexResponder)> {
9014        if let SocketRequest::GetBindToInterfaceIndex { responder } = self {
9015            Some((responder))
9016        } else {
9017            None
9018        }
9019    }
9020
9021    #[allow(irrefutable_let_patterns)]
9022    pub fn into_set_timestamp(
9023        self,
9024    ) -> Option<(fidl_fuchsia_posix_socket::TimestampOption, SocketSetTimestampResponder)> {
9025        if let SocketRequest::SetTimestamp { value, responder } = self {
9026            Some((value, responder))
9027        } else {
9028            None
9029        }
9030    }
9031
9032    #[allow(irrefutable_let_patterns)]
9033    pub fn into_get_timestamp(self) -> Option<(SocketGetTimestampResponder)> {
9034        if let SocketRequest::GetTimestamp { responder } = self {
9035            Some((responder))
9036        } else {
9037            None
9038        }
9039    }
9040
9041    #[allow(irrefutable_let_patterns)]
9042    pub fn into_set_mark(
9043        self,
9044    ) -> Option<(
9045        fidl_fuchsia_net::MarkDomain,
9046        fidl_fuchsia_posix_socket::OptionalUint32,
9047        SocketSetMarkResponder,
9048    )> {
9049        if let SocketRequest::SetMark { domain, mark, responder } = self {
9050            Some((domain, mark, responder))
9051        } else {
9052            None
9053        }
9054    }
9055
9056    #[allow(irrefutable_let_patterns)]
9057    pub fn into_get_mark(self) -> Option<(fidl_fuchsia_net::MarkDomain, SocketGetMarkResponder)> {
9058        if let SocketRequest::GetMark { domain, responder } = self {
9059            Some((domain, responder))
9060        } else {
9061            None
9062        }
9063    }
9064
9065    #[allow(irrefutable_let_patterns)]
9066    pub fn into_get_cookie(self) -> Option<(SocketGetCookieResponder)> {
9067        if let SocketRequest::GetCookie { responder } = self {
9068            Some((responder))
9069        } else {
9070            None
9071        }
9072    }
9073
9074    #[allow(irrefutable_let_patterns)]
9075    pub fn into_bind(self) -> Option<(fidl_fuchsia_net::SocketAddress, SocketBindResponder)> {
9076        if let SocketRequest::Bind { addr, responder } = self {
9077            Some((addr, responder))
9078        } else {
9079            None
9080        }
9081    }
9082
9083    #[allow(irrefutable_let_patterns)]
9084    pub fn into_connect(self) -> Option<(fidl_fuchsia_net::SocketAddress, SocketConnectResponder)> {
9085        if let SocketRequest::Connect { addr, responder } = self {
9086            Some((addr, responder))
9087        } else {
9088            None
9089        }
9090    }
9091
9092    #[allow(irrefutable_let_patterns)]
9093    pub fn into_disconnect(self) -> Option<(SocketDisconnectResponder)> {
9094        if let SocketRequest::Disconnect { responder } = self {
9095            Some((responder))
9096        } else {
9097            None
9098        }
9099    }
9100
9101    #[allow(irrefutable_let_patterns)]
9102    pub fn into_get_sock_name(self) -> Option<(SocketGetSockNameResponder)> {
9103        if let SocketRequest::GetSockName { responder } = self {
9104            Some((responder))
9105        } else {
9106            None
9107        }
9108    }
9109
9110    #[allow(irrefutable_let_patterns)]
9111    pub fn into_get_peer_name(self) -> Option<(SocketGetPeerNameResponder)> {
9112        if let SocketRequest::GetPeerName { responder } = self {
9113            Some((responder))
9114        } else {
9115            None
9116        }
9117    }
9118
9119    #[allow(irrefutable_let_patterns)]
9120    pub fn into_shutdown(
9121        self,
9122    ) -> Option<(fidl_fuchsia_posix_socket::ShutdownMode, SocketShutdownResponder)> {
9123        if let SocketRequest::Shutdown { mode, responder } = self {
9124            Some((mode, responder))
9125        } else {
9126            None
9127        }
9128    }
9129
9130    #[allow(irrefutable_let_patterns)]
9131    pub fn into_set_ip_type_of_service(self) -> Option<(u8, SocketSetIpTypeOfServiceResponder)> {
9132        if let SocketRequest::SetIpTypeOfService { value, responder } = self {
9133            Some((value, responder))
9134        } else {
9135            None
9136        }
9137    }
9138
9139    #[allow(irrefutable_let_patterns)]
9140    pub fn into_get_ip_type_of_service(self) -> Option<(SocketGetIpTypeOfServiceResponder)> {
9141        if let SocketRequest::GetIpTypeOfService { responder } = self {
9142            Some((responder))
9143        } else {
9144            None
9145        }
9146    }
9147
9148    #[allow(irrefutable_let_patterns)]
9149    pub fn into_set_ip_ttl(
9150        self,
9151    ) -> Option<(fidl_fuchsia_posix_socket::OptionalUint8, SocketSetIpTtlResponder)> {
9152        if let SocketRequest::SetIpTtl { value, responder } = self {
9153            Some((value, responder))
9154        } else {
9155            None
9156        }
9157    }
9158
9159    #[allow(irrefutable_let_patterns)]
9160    pub fn into_get_ip_ttl(self) -> Option<(SocketGetIpTtlResponder)> {
9161        if let SocketRequest::GetIpTtl { responder } = self {
9162            Some((responder))
9163        } else {
9164            None
9165        }
9166    }
9167
9168    #[allow(irrefutable_let_patterns)]
9169    pub fn into_set_ip_packet_info(self) -> Option<(bool, SocketSetIpPacketInfoResponder)> {
9170        if let SocketRequest::SetIpPacketInfo { value, responder } = self {
9171            Some((value, responder))
9172        } else {
9173            None
9174        }
9175    }
9176
9177    #[allow(irrefutable_let_patterns)]
9178    pub fn into_get_ip_packet_info(self) -> Option<(SocketGetIpPacketInfoResponder)> {
9179        if let SocketRequest::GetIpPacketInfo { responder } = self {
9180            Some((responder))
9181        } else {
9182            None
9183        }
9184    }
9185
9186    #[allow(irrefutable_let_patterns)]
9187    pub fn into_set_ip_receive_type_of_service(
9188        self,
9189    ) -> Option<(bool, SocketSetIpReceiveTypeOfServiceResponder)> {
9190        if let SocketRequest::SetIpReceiveTypeOfService { value, responder } = self {
9191            Some((value, responder))
9192        } else {
9193            None
9194        }
9195    }
9196
9197    #[allow(irrefutable_let_patterns)]
9198    pub fn into_get_ip_receive_type_of_service(
9199        self,
9200    ) -> Option<(SocketGetIpReceiveTypeOfServiceResponder)> {
9201        if let SocketRequest::GetIpReceiveTypeOfService { responder } = self {
9202            Some((responder))
9203        } else {
9204            None
9205        }
9206    }
9207
9208    #[allow(irrefutable_let_patterns)]
9209    pub fn into_set_ip_receive_ttl(self) -> Option<(bool, SocketSetIpReceiveTtlResponder)> {
9210        if let SocketRequest::SetIpReceiveTtl { value, responder } = self {
9211            Some((value, responder))
9212        } else {
9213            None
9214        }
9215    }
9216
9217    #[allow(irrefutable_let_patterns)]
9218    pub fn into_get_ip_receive_ttl(self) -> Option<(SocketGetIpReceiveTtlResponder)> {
9219        if let SocketRequest::GetIpReceiveTtl { responder } = self {
9220            Some((responder))
9221        } else {
9222            None
9223        }
9224    }
9225
9226    #[allow(irrefutable_let_patterns)]
9227    pub fn into_set_ip_multicast_interface(
9228        self,
9229    ) -> Option<(u64, fidl_fuchsia_net::Ipv4Address, SocketSetIpMulticastInterfaceResponder)> {
9230        if let SocketRequest::SetIpMulticastInterface { iface, address, responder } = self {
9231            Some((iface, address, responder))
9232        } else {
9233            None
9234        }
9235    }
9236
9237    #[allow(irrefutable_let_patterns)]
9238    pub fn into_get_ip_multicast_interface(
9239        self,
9240    ) -> Option<(SocketGetIpMulticastInterfaceResponder)> {
9241        if let SocketRequest::GetIpMulticastInterface { responder } = self {
9242            Some((responder))
9243        } else {
9244            None
9245        }
9246    }
9247
9248    #[allow(irrefutable_let_patterns)]
9249    pub fn into_set_ip_multicast_ttl(
9250        self,
9251    ) -> Option<(fidl_fuchsia_posix_socket::OptionalUint8, SocketSetIpMulticastTtlResponder)> {
9252        if let SocketRequest::SetIpMulticastTtl { value, responder } = self {
9253            Some((value, responder))
9254        } else {
9255            None
9256        }
9257    }
9258
9259    #[allow(irrefutable_let_patterns)]
9260    pub fn into_get_ip_multicast_ttl(self) -> Option<(SocketGetIpMulticastTtlResponder)> {
9261        if let SocketRequest::GetIpMulticastTtl { responder } = self {
9262            Some((responder))
9263        } else {
9264            None
9265        }
9266    }
9267
9268    #[allow(irrefutable_let_patterns)]
9269    pub fn into_set_ip_multicast_loopback(
9270        self,
9271    ) -> Option<(bool, SocketSetIpMulticastLoopbackResponder)> {
9272        if let SocketRequest::SetIpMulticastLoopback { value, responder } = self {
9273            Some((value, responder))
9274        } else {
9275            None
9276        }
9277    }
9278
9279    #[allow(irrefutable_let_patterns)]
9280    pub fn into_get_ip_multicast_loopback(self) -> Option<(SocketGetIpMulticastLoopbackResponder)> {
9281        if let SocketRequest::GetIpMulticastLoopback { responder } = self {
9282            Some((responder))
9283        } else {
9284            None
9285        }
9286    }
9287
9288    #[allow(irrefutable_let_patterns)]
9289    pub fn into_add_ip_membership(
9290        self,
9291    ) -> Option<(fidl_fuchsia_posix_socket::IpMulticastMembership, SocketAddIpMembershipResponder)>
9292    {
9293        if let SocketRequest::AddIpMembership { membership, responder } = self {
9294            Some((membership, responder))
9295        } else {
9296            None
9297        }
9298    }
9299
9300    #[allow(irrefutable_let_patterns)]
9301    pub fn into_drop_ip_membership(
9302        self,
9303    ) -> Option<(fidl_fuchsia_posix_socket::IpMulticastMembership, SocketDropIpMembershipResponder)>
9304    {
9305        if let SocketRequest::DropIpMembership { membership, responder } = self {
9306            Some((membership, responder))
9307        } else {
9308            None
9309        }
9310    }
9311
9312    #[allow(irrefutable_let_patterns)]
9313    pub fn into_set_ip_transparent(self) -> Option<(bool, SocketSetIpTransparentResponder)> {
9314        if let SocketRequest::SetIpTransparent { value, responder } = self {
9315            Some((value, responder))
9316        } else {
9317            None
9318        }
9319    }
9320
9321    #[allow(irrefutable_let_patterns)]
9322    pub fn into_get_ip_transparent(self) -> Option<(SocketGetIpTransparentResponder)> {
9323        if let SocketRequest::GetIpTransparent { responder } = self {
9324            Some((responder))
9325        } else {
9326            None
9327        }
9328    }
9329
9330    #[allow(irrefutable_let_patterns)]
9331    pub fn into_set_ip_receive_original_destination_address(
9332        self,
9333    ) -> Option<(bool, SocketSetIpReceiveOriginalDestinationAddressResponder)> {
9334        if let SocketRequest::SetIpReceiveOriginalDestinationAddress { value, responder } = self {
9335            Some((value, responder))
9336        } else {
9337            None
9338        }
9339    }
9340
9341    #[allow(irrefutable_let_patterns)]
9342    pub fn into_get_ip_receive_original_destination_address(
9343        self,
9344    ) -> Option<(SocketGetIpReceiveOriginalDestinationAddressResponder)> {
9345        if let SocketRequest::GetIpReceiveOriginalDestinationAddress { responder } = self {
9346            Some((responder))
9347        } else {
9348            None
9349        }
9350    }
9351
9352    #[allow(irrefutable_let_patterns)]
9353    pub fn into_add_ipv6_membership(
9354        self,
9355    ) -> Option<(
9356        fidl_fuchsia_posix_socket::Ipv6MulticastMembership,
9357        SocketAddIpv6MembershipResponder,
9358    )> {
9359        if let SocketRequest::AddIpv6Membership { membership, responder } = self {
9360            Some((membership, responder))
9361        } else {
9362            None
9363        }
9364    }
9365
9366    #[allow(irrefutable_let_patterns)]
9367    pub fn into_drop_ipv6_membership(
9368        self,
9369    ) -> Option<(
9370        fidl_fuchsia_posix_socket::Ipv6MulticastMembership,
9371        SocketDropIpv6MembershipResponder,
9372    )> {
9373        if let SocketRequest::DropIpv6Membership { membership, responder } = self {
9374            Some((membership, responder))
9375        } else {
9376            None
9377        }
9378    }
9379
9380    #[allow(irrefutable_let_patterns)]
9381    pub fn into_set_ipv6_multicast_interface(
9382        self,
9383    ) -> Option<(u64, SocketSetIpv6MulticastInterfaceResponder)> {
9384        if let SocketRequest::SetIpv6MulticastInterface { value, responder } = self {
9385            Some((value, responder))
9386        } else {
9387            None
9388        }
9389    }
9390
9391    #[allow(irrefutable_let_patterns)]
9392    pub fn into_get_ipv6_multicast_interface(
9393        self,
9394    ) -> Option<(SocketGetIpv6MulticastInterfaceResponder)> {
9395        if let SocketRequest::GetIpv6MulticastInterface { responder } = self {
9396            Some((responder))
9397        } else {
9398            None
9399        }
9400    }
9401
9402    #[allow(irrefutable_let_patterns)]
9403    pub fn into_set_ipv6_unicast_hops(
9404        self,
9405    ) -> Option<(fidl_fuchsia_posix_socket::OptionalUint8, SocketSetIpv6UnicastHopsResponder)> {
9406        if let SocketRequest::SetIpv6UnicastHops { value, responder } = self {
9407            Some((value, responder))
9408        } else {
9409            None
9410        }
9411    }
9412
9413    #[allow(irrefutable_let_patterns)]
9414    pub fn into_get_ipv6_unicast_hops(self) -> Option<(SocketGetIpv6UnicastHopsResponder)> {
9415        if let SocketRequest::GetIpv6UnicastHops { responder } = self {
9416            Some((responder))
9417        } else {
9418            None
9419        }
9420    }
9421
9422    #[allow(irrefutable_let_patterns)]
9423    pub fn into_set_ipv6_receive_hop_limit(
9424        self,
9425    ) -> Option<(bool, SocketSetIpv6ReceiveHopLimitResponder)> {
9426        if let SocketRequest::SetIpv6ReceiveHopLimit { value, responder } = self {
9427            Some((value, responder))
9428        } else {
9429            None
9430        }
9431    }
9432
9433    #[allow(irrefutable_let_patterns)]
9434    pub fn into_get_ipv6_receive_hop_limit(
9435        self,
9436    ) -> Option<(SocketGetIpv6ReceiveHopLimitResponder)> {
9437        if let SocketRequest::GetIpv6ReceiveHopLimit { responder } = self {
9438            Some((responder))
9439        } else {
9440            None
9441        }
9442    }
9443
9444    #[allow(irrefutable_let_patterns)]
9445    pub fn into_set_ipv6_multicast_hops(
9446        self,
9447    ) -> Option<(fidl_fuchsia_posix_socket::OptionalUint8, SocketSetIpv6MulticastHopsResponder)>
9448    {
9449        if let SocketRequest::SetIpv6MulticastHops { value, responder } = self {
9450            Some((value, responder))
9451        } else {
9452            None
9453        }
9454    }
9455
9456    #[allow(irrefutable_let_patterns)]
9457    pub fn into_get_ipv6_multicast_hops(self) -> Option<(SocketGetIpv6MulticastHopsResponder)> {
9458        if let SocketRequest::GetIpv6MulticastHops { responder } = self {
9459            Some((responder))
9460        } else {
9461            None
9462        }
9463    }
9464
9465    #[allow(irrefutable_let_patterns)]
9466    pub fn into_set_ipv6_multicast_loopback(
9467        self,
9468    ) -> Option<(bool, SocketSetIpv6MulticastLoopbackResponder)> {
9469        if let SocketRequest::SetIpv6MulticastLoopback { value, responder } = self {
9470            Some((value, responder))
9471        } else {
9472            None
9473        }
9474    }
9475
9476    #[allow(irrefutable_let_patterns)]
9477    pub fn into_get_ipv6_multicast_loopback(
9478        self,
9479    ) -> Option<(SocketGetIpv6MulticastLoopbackResponder)> {
9480        if let SocketRequest::GetIpv6MulticastLoopback { responder } = self {
9481            Some((responder))
9482        } else {
9483            None
9484        }
9485    }
9486
9487    #[allow(irrefutable_let_patterns)]
9488    pub fn into_set_ipv6_only(self) -> Option<(bool, SocketSetIpv6OnlyResponder)> {
9489        if let SocketRequest::SetIpv6Only { value, responder } = self {
9490            Some((value, responder))
9491        } else {
9492            None
9493        }
9494    }
9495
9496    #[allow(irrefutable_let_patterns)]
9497    pub fn into_get_ipv6_only(self) -> Option<(SocketGetIpv6OnlyResponder)> {
9498        if let SocketRequest::GetIpv6Only { responder } = self {
9499            Some((responder))
9500        } else {
9501            None
9502        }
9503    }
9504
9505    #[allow(irrefutable_let_patterns)]
9506    pub fn into_set_ipv6_receive_traffic_class(
9507        self,
9508    ) -> Option<(bool, SocketSetIpv6ReceiveTrafficClassResponder)> {
9509        if let SocketRequest::SetIpv6ReceiveTrafficClass { value, responder } = self {
9510            Some((value, responder))
9511        } else {
9512            None
9513        }
9514    }
9515
9516    #[allow(irrefutable_let_patterns)]
9517    pub fn into_get_ipv6_receive_traffic_class(
9518        self,
9519    ) -> Option<(SocketGetIpv6ReceiveTrafficClassResponder)> {
9520        if let SocketRequest::GetIpv6ReceiveTrafficClass { responder } = self {
9521            Some((responder))
9522        } else {
9523            None
9524        }
9525    }
9526
9527    #[allow(irrefutable_let_patterns)]
9528    pub fn into_set_ipv6_traffic_class(
9529        self,
9530    ) -> Option<(fidl_fuchsia_posix_socket::OptionalUint8, SocketSetIpv6TrafficClassResponder)>
9531    {
9532        if let SocketRequest::SetIpv6TrafficClass { value, responder } = self {
9533            Some((value, responder))
9534        } else {
9535            None
9536        }
9537    }
9538
9539    #[allow(irrefutable_let_patterns)]
9540    pub fn into_get_ipv6_traffic_class(self) -> Option<(SocketGetIpv6TrafficClassResponder)> {
9541        if let SocketRequest::GetIpv6TrafficClass { responder } = self {
9542            Some((responder))
9543        } else {
9544            None
9545        }
9546    }
9547
9548    #[allow(irrefutable_let_patterns)]
9549    pub fn into_set_ipv6_receive_packet_info(
9550        self,
9551    ) -> Option<(bool, SocketSetIpv6ReceivePacketInfoResponder)> {
9552        if let SocketRequest::SetIpv6ReceivePacketInfo { value, responder } = self {
9553            Some((value, responder))
9554        } else {
9555            None
9556        }
9557    }
9558
9559    #[allow(irrefutable_let_patterns)]
9560    pub fn into_get_ipv6_receive_packet_info(
9561        self,
9562    ) -> Option<(SocketGetIpv6ReceivePacketInfoResponder)> {
9563        if let SocketRequest::GetIpv6ReceivePacketInfo { responder } = self {
9564            Some((responder))
9565        } else {
9566            None
9567        }
9568    }
9569
9570    #[allow(irrefutable_let_patterns)]
9571    pub fn into_get_original_destination(self) -> Option<(SocketGetOriginalDestinationResponder)> {
9572        if let SocketRequest::GetOriginalDestination { responder } = self {
9573            Some((responder))
9574        } else {
9575            None
9576        }
9577    }
9578
9579    #[allow(irrefutable_let_patterns)]
9580    pub fn into_describe(self) -> Option<(SocketDescribeResponder)> {
9581        if let SocketRequest::Describe { responder } = self {
9582            Some((responder))
9583        } else {
9584            None
9585        }
9586    }
9587
9588    #[allow(irrefutable_let_patterns)]
9589    pub fn into_recv_msg(
9590        self,
9591    ) -> Option<(bool, u32, bool, fidl_fuchsia_posix_socket::RecvMsgFlags, SocketRecvMsgResponder)>
9592    {
9593        if let SocketRequest::RecvMsg { want_addr, data_len, want_control, flags, responder } = self
9594        {
9595            Some((want_addr, data_len, want_control, flags, responder))
9596        } else {
9597            None
9598        }
9599    }
9600
9601    #[allow(irrefutable_let_patterns)]
9602    pub fn into_send_msg(
9603        self,
9604    ) -> Option<(
9605        Option<Box<fidl_fuchsia_net::SocketAddress>>,
9606        Vec<u8>,
9607        fidl_fuchsia_posix_socket::NetworkSocketSendControlData,
9608        fidl_fuchsia_posix_socket::SendMsgFlags,
9609        SocketSendMsgResponder,
9610    )> {
9611        if let SocketRequest::SendMsg { addr, data, control, flags, responder } = self {
9612            Some((addr, data, control, flags, responder))
9613        } else {
9614            None
9615        }
9616    }
9617
9618    #[allow(irrefutable_let_patterns)]
9619    pub fn into_get_info(self) -> Option<(SocketGetInfoResponder)> {
9620        if let SocketRequest::GetInfo { responder } = self {
9621            Some((responder))
9622        } else {
9623            None
9624        }
9625    }
9626
9627    #[allow(irrefutable_let_patterns)]
9628    pub fn into_set_ip_header_included(self) -> Option<(bool, SocketSetIpHeaderIncludedResponder)> {
9629        if let SocketRequest::SetIpHeaderIncluded { value, responder } = self {
9630            Some((value, responder))
9631        } else {
9632            None
9633        }
9634    }
9635
9636    #[allow(irrefutable_let_patterns)]
9637    pub fn into_get_ip_header_included(self) -> Option<(SocketGetIpHeaderIncludedResponder)> {
9638        if let SocketRequest::GetIpHeaderIncluded { responder } = self {
9639            Some((responder))
9640        } else {
9641            None
9642        }
9643    }
9644
9645    #[allow(irrefutable_let_patterns)]
9646    pub fn into_set_icmpv6_filter(self) -> Option<(Icmpv6Filter, SocketSetIcmpv6FilterResponder)> {
9647        if let SocketRequest::SetIcmpv6Filter { filter, responder } = self {
9648            Some((filter, responder))
9649        } else {
9650            None
9651        }
9652    }
9653
9654    #[allow(irrefutable_let_patterns)]
9655    pub fn into_get_icmpv6_filter(self) -> Option<(SocketGetIcmpv6FilterResponder)> {
9656        if let SocketRequest::GetIcmpv6Filter { responder } = self {
9657            Some((responder))
9658        } else {
9659            None
9660        }
9661    }
9662
9663    #[allow(irrefutable_let_patterns)]
9664    pub fn into_set_ipv6_checksum(
9665        self,
9666    ) -> Option<(Ipv6ChecksumConfiguration, SocketSetIpv6ChecksumResponder)> {
9667        if let SocketRequest::SetIpv6Checksum { config, responder } = self {
9668            Some((config, responder))
9669        } else {
9670            None
9671        }
9672    }
9673
9674    #[allow(irrefutable_let_patterns)]
9675    pub fn into_get_ipv6_checksum(self) -> Option<(SocketGetIpv6ChecksumResponder)> {
9676        if let SocketRequest::GetIpv6Checksum { responder } = self {
9677            Some((responder))
9678        } else {
9679            None
9680        }
9681    }
9682
9683    /// Name of the method defined in FIDL
9684    pub fn method_name(&self) -> &'static str {
9685        match *self {
9686            SocketRequest::Clone { .. } => "clone",
9687            SocketRequest::Close { .. } => "close",
9688            SocketRequest::Query { .. } => "query",
9689            SocketRequest::SetReuseAddress { .. } => "set_reuse_address",
9690            SocketRequest::GetReuseAddress { .. } => "get_reuse_address",
9691            SocketRequest::GetError { .. } => "get_error",
9692            SocketRequest::SetBroadcast { .. } => "set_broadcast",
9693            SocketRequest::GetBroadcast { .. } => "get_broadcast",
9694            SocketRequest::SetSendBuffer { .. } => "set_send_buffer",
9695            SocketRequest::GetSendBuffer { .. } => "get_send_buffer",
9696            SocketRequest::SetReceiveBuffer { .. } => "set_receive_buffer",
9697            SocketRequest::GetReceiveBuffer { .. } => "get_receive_buffer",
9698            SocketRequest::SetKeepAlive { .. } => "set_keep_alive",
9699            SocketRequest::GetKeepAlive { .. } => "get_keep_alive",
9700            SocketRequest::SetOutOfBandInline { .. } => "set_out_of_band_inline",
9701            SocketRequest::GetOutOfBandInline { .. } => "get_out_of_band_inline",
9702            SocketRequest::SetNoCheck { .. } => "set_no_check",
9703            SocketRequest::GetNoCheck { .. } => "get_no_check",
9704            SocketRequest::SetLinger { .. } => "set_linger",
9705            SocketRequest::GetLinger { .. } => "get_linger",
9706            SocketRequest::SetReusePort { .. } => "set_reuse_port",
9707            SocketRequest::GetReusePort { .. } => "get_reuse_port",
9708            SocketRequest::GetAcceptConn { .. } => "get_accept_conn",
9709            SocketRequest::SetBindToDevice { .. } => "set_bind_to_device",
9710            SocketRequest::GetBindToDevice { .. } => "get_bind_to_device",
9711            SocketRequest::SetBindToInterfaceIndex { .. } => "set_bind_to_interface_index",
9712            SocketRequest::GetBindToInterfaceIndex { .. } => "get_bind_to_interface_index",
9713            SocketRequest::SetTimestamp { .. } => "set_timestamp",
9714            SocketRequest::GetTimestamp { .. } => "get_timestamp",
9715            SocketRequest::SetMark { .. } => "set_mark",
9716            SocketRequest::GetMark { .. } => "get_mark",
9717            SocketRequest::GetCookie { .. } => "get_cookie",
9718            SocketRequest::Bind { .. } => "bind",
9719            SocketRequest::Connect { .. } => "connect",
9720            SocketRequest::Disconnect { .. } => "disconnect",
9721            SocketRequest::GetSockName { .. } => "get_sock_name",
9722            SocketRequest::GetPeerName { .. } => "get_peer_name",
9723            SocketRequest::Shutdown { .. } => "shutdown",
9724            SocketRequest::SetIpTypeOfService { .. } => "set_ip_type_of_service",
9725            SocketRequest::GetIpTypeOfService { .. } => "get_ip_type_of_service",
9726            SocketRequest::SetIpTtl { .. } => "set_ip_ttl",
9727            SocketRequest::GetIpTtl { .. } => "get_ip_ttl",
9728            SocketRequest::SetIpPacketInfo { .. } => "set_ip_packet_info",
9729            SocketRequest::GetIpPacketInfo { .. } => "get_ip_packet_info",
9730            SocketRequest::SetIpReceiveTypeOfService { .. } => "set_ip_receive_type_of_service",
9731            SocketRequest::GetIpReceiveTypeOfService { .. } => "get_ip_receive_type_of_service",
9732            SocketRequest::SetIpReceiveTtl { .. } => "set_ip_receive_ttl",
9733            SocketRequest::GetIpReceiveTtl { .. } => "get_ip_receive_ttl",
9734            SocketRequest::SetIpMulticastInterface { .. } => "set_ip_multicast_interface",
9735            SocketRequest::GetIpMulticastInterface { .. } => "get_ip_multicast_interface",
9736            SocketRequest::SetIpMulticastTtl { .. } => "set_ip_multicast_ttl",
9737            SocketRequest::GetIpMulticastTtl { .. } => "get_ip_multicast_ttl",
9738            SocketRequest::SetIpMulticastLoopback { .. } => "set_ip_multicast_loopback",
9739            SocketRequest::GetIpMulticastLoopback { .. } => "get_ip_multicast_loopback",
9740            SocketRequest::AddIpMembership { .. } => "add_ip_membership",
9741            SocketRequest::DropIpMembership { .. } => "drop_ip_membership",
9742            SocketRequest::SetIpTransparent { .. } => "set_ip_transparent",
9743            SocketRequest::GetIpTransparent { .. } => "get_ip_transparent",
9744            SocketRequest::SetIpReceiveOriginalDestinationAddress { .. } => {
9745                "set_ip_receive_original_destination_address"
9746            }
9747            SocketRequest::GetIpReceiveOriginalDestinationAddress { .. } => {
9748                "get_ip_receive_original_destination_address"
9749            }
9750            SocketRequest::AddIpv6Membership { .. } => "add_ipv6_membership",
9751            SocketRequest::DropIpv6Membership { .. } => "drop_ipv6_membership",
9752            SocketRequest::SetIpv6MulticastInterface { .. } => "set_ipv6_multicast_interface",
9753            SocketRequest::GetIpv6MulticastInterface { .. } => "get_ipv6_multicast_interface",
9754            SocketRequest::SetIpv6UnicastHops { .. } => "set_ipv6_unicast_hops",
9755            SocketRequest::GetIpv6UnicastHops { .. } => "get_ipv6_unicast_hops",
9756            SocketRequest::SetIpv6ReceiveHopLimit { .. } => "set_ipv6_receive_hop_limit",
9757            SocketRequest::GetIpv6ReceiveHopLimit { .. } => "get_ipv6_receive_hop_limit",
9758            SocketRequest::SetIpv6MulticastHops { .. } => "set_ipv6_multicast_hops",
9759            SocketRequest::GetIpv6MulticastHops { .. } => "get_ipv6_multicast_hops",
9760            SocketRequest::SetIpv6MulticastLoopback { .. } => "set_ipv6_multicast_loopback",
9761            SocketRequest::GetIpv6MulticastLoopback { .. } => "get_ipv6_multicast_loopback",
9762            SocketRequest::SetIpv6Only { .. } => "set_ipv6_only",
9763            SocketRequest::GetIpv6Only { .. } => "get_ipv6_only",
9764            SocketRequest::SetIpv6ReceiveTrafficClass { .. } => "set_ipv6_receive_traffic_class",
9765            SocketRequest::GetIpv6ReceiveTrafficClass { .. } => "get_ipv6_receive_traffic_class",
9766            SocketRequest::SetIpv6TrafficClass { .. } => "set_ipv6_traffic_class",
9767            SocketRequest::GetIpv6TrafficClass { .. } => "get_ipv6_traffic_class",
9768            SocketRequest::SetIpv6ReceivePacketInfo { .. } => "set_ipv6_receive_packet_info",
9769            SocketRequest::GetIpv6ReceivePacketInfo { .. } => "get_ipv6_receive_packet_info",
9770            SocketRequest::GetOriginalDestination { .. } => "get_original_destination",
9771            SocketRequest::Describe { .. } => "describe",
9772            SocketRequest::RecvMsg { .. } => "recv_msg",
9773            SocketRequest::SendMsg { .. } => "send_msg",
9774            SocketRequest::GetInfo { .. } => "get_info",
9775            SocketRequest::SetIpHeaderIncluded { .. } => "set_ip_header_included",
9776            SocketRequest::GetIpHeaderIncluded { .. } => "get_ip_header_included",
9777            SocketRequest::SetIcmpv6Filter { .. } => "set_icmpv6_filter",
9778            SocketRequest::GetIcmpv6Filter { .. } => "get_icmpv6_filter",
9779            SocketRequest::SetIpv6Checksum { .. } => "set_ipv6_checksum",
9780            SocketRequest::GetIpv6Checksum { .. } => "get_ipv6_checksum",
9781        }
9782    }
9783}
9784
9785#[derive(Debug, Clone)]
9786pub struct SocketControlHandle {
9787    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
9788}
9789
9790impl fidl::endpoints::ControlHandle for SocketControlHandle {
9791    fn shutdown(&self) {
9792        self.inner.shutdown()
9793    }
9794    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
9795        self.inner.shutdown_with_epitaph(status)
9796    }
9797
9798    fn is_closed(&self) -> bool {
9799        self.inner.channel().is_closed()
9800    }
9801    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
9802        self.inner.channel().on_closed()
9803    }
9804
9805    #[cfg(target_os = "fuchsia")]
9806    fn signal_peer(
9807        &self,
9808        clear_mask: zx::Signals,
9809        set_mask: zx::Signals,
9810    ) -> Result<(), zx_status::Status> {
9811        use fidl::Peered;
9812        self.inner.channel().signal_peer(clear_mask, set_mask)
9813    }
9814}
9815
9816impl SocketControlHandle {}
9817
9818#[must_use = "FIDL methods require a response to be sent"]
9819#[derive(Debug)]
9820pub struct SocketCloseResponder {
9821    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
9822    tx_id: u32,
9823}
9824
9825/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
9826/// if the responder is dropped without sending a response, so that the client
9827/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
9828impl std::ops::Drop for SocketCloseResponder {
9829    fn drop(&mut self) {
9830        self.control_handle.shutdown();
9831        // Safety: drops once, never accessed again
9832        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9833    }
9834}
9835
9836impl fidl::endpoints::Responder for SocketCloseResponder {
9837    type ControlHandle = SocketControlHandle;
9838
9839    fn control_handle(&self) -> &SocketControlHandle {
9840        &self.control_handle
9841    }
9842
9843    fn drop_without_shutdown(mut self) {
9844        // Safety: drops once, never accessed again due to mem::forget
9845        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9846        // Prevent Drop from running (which would shut down the channel)
9847        std::mem::forget(self);
9848    }
9849}
9850
9851impl SocketCloseResponder {
9852    /// Sends a response to the FIDL transaction.
9853    ///
9854    /// Sets the channel to shutdown if an error occurs.
9855    pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
9856        let _result = self.send_raw(result);
9857        if _result.is_err() {
9858            self.control_handle.shutdown();
9859        }
9860        self.drop_without_shutdown();
9861        _result
9862    }
9863
9864    /// Similar to "send" but does not shutdown the channel if an error occurs.
9865    pub fn send_no_shutdown_on_err(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
9866        let _result = self.send_raw(result);
9867        self.drop_without_shutdown();
9868        _result
9869    }
9870
9871    fn send_raw(&self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
9872        self.control_handle
9873            .inner
9874            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>>(
9875                result,
9876                self.tx_id,
9877                0x5ac5d459ad7f657e,
9878                fidl::encoding::DynamicFlags::empty(),
9879            )
9880    }
9881}
9882
9883#[must_use = "FIDL methods require a response to be sent"]
9884#[derive(Debug)]
9885pub struct SocketQueryResponder {
9886    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
9887    tx_id: u32,
9888}
9889
9890/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
9891/// if the responder is dropped without sending a response, so that the client
9892/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
9893impl std::ops::Drop for SocketQueryResponder {
9894    fn drop(&mut self) {
9895        self.control_handle.shutdown();
9896        // Safety: drops once, never accessed again
9897        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9898    }
9899}
9900
9901impl fidl::endpoints::Responder for SocketQueryResponder {
9902    type ControlHandle = SocketControlHandle;
9903
9904    fn control_handle(&self) -> &SocketControlHandle {
9905        &self.control_handle
9906    }
9907
9908    fn drop_without_shutdown(mut self) {
9909        // Safety: drops once, never accessed again due to mem::forget
9910        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9911        // Prevent Drop from running (which would shut down the channel)
9912        std::mem::forget(self);
9913    }
9914}
9915
9916impl SocketQueryResponder {
9917    /// Sends a response to the FIDL transaction.
9918    ///
9919    /// Sets the channel to shutdown if an error occurs.
9920    pub fn send(self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
9921        let _result = self.send_raw(protocol);
9922        if _result.is_err() {
9923            self.control_handle.shutdown();
9924        }
9925        self.drop_without_shutdown();
9926        _result
9927    }
9928
9929    /// Similar to "send" but does not shutdown the channel if an error occurs.
9930    pub fn send_no_shutdown_on_err(self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
9931        let _result = self.send_raw(protocol);
9932        self.drop_without_shutdown();
9933        _result
9934    }
9935
9936    fn send_raw(&self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
9937        self.control_handle.inner.send::<fidl_fuchsia_unknown::QueryableQueryResponse>(
9938            (protocol,),
9939            self.tx_id,
9940            0x2658edee9decfc06,
9941            fidl::encoding::DynamicFlags::empty(),
9942        )
9943    }
9944}
9945
9946#[must_use = "FIDL methods require a response to be sent"]
9947#[derive(Debug)]
9948pub struct SocketSetReuseAddressResponder {
9949    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
9950    tx_id: u32,
9951}
9952
9953/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
9954/// if the responder is dropped without sending a response, so that the client
9955/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
9956impl std::ops::Drop for SocketSetReuseAddressResponder {
9957    fn drop(&mut self) {
9958        self.control_handle.shutdown();
9959        // Safety: drops once, never accessed again
9960        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9961    }
9962}
9963
9964impl fidl::endpoints::Responder for SocketSetReuseAddressResponder {
9965    type ControlHandle = SocketControlHandle;
9966
9967    fn control_handle(&self) -> &SocketControlHandle {
9968        &self.control_handle
9969    }
9970
9971    fn drop_without_shutdown(mut self) {
9972        // Safety: drops once, never accessed again due to mem::forget
9973        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9974        // Prevent Drop from running (which would shut down the channel)
9975        std::mem::forget(self);
9976    }
9977}
9978
9979impl SocketSetReuseAddressResponder {
9980    /// Sends a response to the FIDL transaction.
9981    ///
9982    /// Sets the channel to shutdown if an error occurs.
9983    pub fn send(
9984        self,
9985        mut result: Result<(), fidl_fuchsia_posix::Errno>,
9986    ) -> Result<(), fidl::Error> {
9987        let _result = self.send_raw(result);
9988        if _result.is_err() {
9989            self.control_handle.shutdown();
9990        }
9991        self.drop_without_shutdown();
9992        _result
9993    }
9994
9995    /// Similar to "send" but does not shutdown the channel if an error occurs.
9996    pub fn send_no_shutdown_on_err(
9997        self,
9998        mut result: Result<(), fidl_fuchsia_posix::Errno>,
9999    ) -> Result<(), fidl::Error> {
10000        let _result = self.send_raw(result);
10001        self.drop_without_shutdown();
10002        _result
10003    }
10004
10005    fn send_raw(
10006        &self,
10007        mut result: Result<(), fidl_fuchsia_posix::Errno>,
10008    ) -> Result<(), fidl::Error> {
10009        self.control_handle.inner.send::<fidl::encoding::ResultType<
10010            fidl::encoding::EmptyStruct,
10011            fidl_fuchsia_posix::Errno,
10012        >>(
10013            result,
10014            self.tx_id,
10015            0x1fd74ee8b9a4a876,
10016            fidl::encoding::DynamicFlags::empty(),
10017        )
10018    }
10019}
10020
10021#[must_use = "FIDL methods require a response to be sent"]
10022#[derive(Debug)]
10023pub struct SocketGetReuseAddressResponder {
10024    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
10025    tx_id: u32,
10026}
10027
10028/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
10029/// if the responder is dropped without sending a response, so that the client
10030/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
10031impl std::ops::Drop for SocketGetReuseAddressResponder {
10032    fn drop(&mut self) {
10033        self.control_handle.shutdown();
10034        // Safety: drops once, never accessed again
10035        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10036    }
10037}
10038
10039impl fidl::endpoints::Responder for SocketGetReuseAddressResponder {
10040    type ControlHandle = SocketControlHandle;
10041
10042    fn control_handle(&self) -> &SocketControlHandle {
10043        &self.control_handle
10044    }
10045
10046    fn drop_without_shutdown(mut self) {
10047        // Safety: drops once, never accessed again due to mem::forget
10048        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10049        // Prevent Drop from running (which would shut down the channel)
10050        std::mem::forget(self);
10051    }
10052}
10053
10054impl SocketGetReuseAddressResponder {
10055    /// Sends a response to the FIDL transaction.
10056    ///
10057    /// Sets the channel to shutdown if an error occurs.
10058    pub fn send(
10059        self,
10060        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
10061    ) -> Result<(), fidl::Error> {
10062        let _result = self.send_raw(result);
10063        if _result.is_err() {
10064            self.control_handle.shutdown();
10065        }
10066        self.drop_without_shutdown();
10067        _result
10068    }
10069
10070    /// Similar to "send" but does not shutdown the channel if an error occurs.
10071    pub fn send_no_shutdown_on_err(
10072        self,
10073        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
10074    ) -> Result<(), fidl::Error> {
10075        let _result = self.send_raw(result);
10076        self.drop_without_shutdown();
10077        _result
10078    }
10079
10080    fn send_raw(
10081        &self,
10082        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
10083    ) -> Result<(), fidl::Error> {
10084        self.control_handle.inner.send::<fidl::encoding::ResultType<
10085            fidl_fuchsia_posix_socket::BaseSocketGetReuseAddressResponse,
10086            fidl_fuchsia_posix::Errno,
10087        >>(
10088            result.map(|value| (value,)),
10089            self.tx_id,
10090            0x67b7206b8d1bc0a5,
10091            fidl::encoding::DynamicFlags::empty(),
10092        )
10093    }
10094}
10095
10096#[must_use = "FIDL methods require a response to be sent"]
10097#[derive(Debug)]
10098pub struct SocketGetErrorResponder {
10099    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
10100    tx_id: u32,
10101}
10102
10103/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
10104/// if the responder is dropped without sending a response, so that the client
10105/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
10106impl std::ops::Drop for SocketGetErrorResponder {
10107    fn drop(&mut self) {
10108        self.control_handle.shutdown();
10109        // Safety: drops once, never accessed again
10110        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10111    }
10112}
10113
10114impl fidl::endpoints::Responder for SocketGetErrorResponder {
10115    type ControlHandle = SocketControlHandle;
10116
10117    fn control_handle(&self) -> &SocketControlHandle {
10118        &self.control_handle
10119    }
10120
10121    fn drop_without_shutdown(mut self) {
10122        // Safety: drops once, never accessed again due to mem::forget
10123        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10124        // Prevent Drop from running (which would shut down the channel)
10125        std::mem::forget(self);
10126    }
10127}
10128
10129impl SocketGetErrorResponder {
10130    /// Sends a response to the FIDL transaction.
10131    ///
10132    /// Sets the channel to shutdown if an error occurs.
10133    pub fn send(
10134        self,
10135        mut result: Result<(), fidl_fuchsia_posix::Errno>,
10136    ) -> Result<(), fidl::Error> {
10137        let _result = self.send_raw(result);
10138        if _result.is_err() {
10139            self.control_handle.shutdown();
10140        }
10141        self.drop_without_shutdown();
10142        _result
10143    }
10144
10145    /// Similar to "send" but does not shutdown the channel if an error occurs.
10146    pub fn send_no_shutdown_on_err(
10147        self,
10148        mut result: Result<(), fidl_fuchsia_posix::Errno>,
10149    ) -> Result<(), fidl::Error> {
10150        let _result = self.send_raw(result);
10151        self.drop_without_shutdown();
10152        _result
10153    }
10154
10155    fn send_raw(
10156        &self,
10157        mut result: Result<(), fidl_fuchsia_posix::Errno>,
10158    ) -> Result<(), fidl::Error> {
10159        self.control_handle.inner.send::<fidl::encoding::ResultType<
10160            fidl::encoding::EmptyStruct,
10161            fidl_fuchsia_posix::Errno,
10162        >>(
10163            result,
10164            self.tx_id,
10165            0x5aad39b33e5f6ebb,
10166            fidl::encoding::DynamicFlags::empty(),
10167        )
10168    }
10169}
10170
10171#[must_use = "FIDL methods require a response to be sent"]
10172#[derive(Debug)]
10173pub struct SocketSetBroadcastResponder {
10174    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
10175    tx_id: u32,
10176}
10177
10178/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
10179/// if the responder is dropped without sending a response, so that the client
10180/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
10181impl std::ops::Drop for SocketSetBroadcastResponder {
10182    fn drop(&mut self) {
10183        self.control_handle.shutdown();
10184        // Safety: drops once, never accessed again
10185        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10186    }
10187}
10188
10189impl fidl::endpoints::Responder for SocketSetBroadcastResponder {
10190    type ControlHandle = SocketControlHandle;
10191
10192    fn control_handle(&self) -> &SocketControlHandle {
10193        &self.control_handle
10194    }
10195
10196    fn drop_without_shutdown(mut self) {
10197        // Safety: drops once, never accessed again due to mem::forget
10198        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10199        // Prevent Drop from running (which would shut down the channel)
10200        std::mem::forget(self);
10201    }
10202}
10203
10204impl SocketSetBroadcastResponder {
10205    /// Sends a response to the FIDL transaction.
10206    ///
10207    /// Sets the channel to shutdown if an error occurs.
10208    pub fn send(
10209        self,
10210        mut result: Result<(), fidl_fuchsia_posix::Errno>,
10211    ) -> Result<(), fidl::Error> {
10212        let _result = self.send_raw(result);
10213        if _result.is_err() {
10214            self.control_handle.shutdown();
10215        }
10216        self.drop_without_shutdown();
10217        _result
10218    }
10219
10220    /// Similar to "send" but does not shutdown the channel if an error occurs.
10221    pub fn send_no_shutdown_on_err(
10222        self,
10223        mut result: Result<(), fidl_fuchsia_posix::Errno>,
10224    ) -> Result<(), fidl::Error> {
10225        let _result = self.send_raw(result);
10226        self.drop_without_shutdown();
10227        _result
10228    }
10229
10230    fn send_raw(
10231        &self,
10232        mut result: Result<(), fidl_fuchsia_posix::Errno>,
10233    ) -> Result<(), fidl::Error> {
10234        self.control_handle.inner.send::<fidl::encoding::ResultType<
10235            fidl::encoding::EmptyStruct,
10236            fidl_fuchsia_posix::Errno,
10237        >>(
10238            result,
10239            self.tx_id,
10240            0x6023e081ce3cd947,
10241            fidl::encoding::DynamicFlags::empty(),
10242        )
10243    }
10244}
10245
10246#[must_use = "FIDL methods require a response to be sent"]
10247#[derive(Debug)]
10248pub struct SocketGetBroadcastResponder {
10249    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
10250    tx_id: u32,
10251}
10252
10253/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
10254/// if the responder is dropped without sending a response, so that the client
10255/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
10256impl std::ops::Drop for SocketGetBroadcastResponder {
10257    fn drop(&mut self) {
10258        self.control_handle.shutdown();
10259        // Safety: drops once, never accessed again
10260        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10261    }
10262}
10263
10264impl fidl::endpoints::Responder for SocketGetBroadcastResponder {
10265    type ControlHandle = SocketControlHandle;
10266
10267    fn control_handle(&self) -> &SocketControlHandle {
10268        &self.control_handle
10269    }
10270
10271    fn drop_without_shutdown(mut self) {
10272        // Safety: drops once, never accessed again due to mem::forget
10273        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10274        // Prevent Drop from running (which would shut down the channel)
10275        std::mem::forget(self);
10276    }
10277}
10278
10279impl SocketGetBroadcastResponder {
10280    /// Sends a response to the FIDL transaction.
10281    ///
10282    /// Sets the channel to shutdown if an error occurs.
10283    pub fn send(
10284        self,
10285        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
10286    ) -> Result<(), fidl::Error> {
10287        let _result = self.send_raw(result);
10288        if _result.is_err() {
10289            self.control_handle.shutdown();
10290        }
10291        self.drop_without_shutdown();
10292        _result
10293    }
10294
10295    /// Similar to "send" but does not shutdown the channel if an error occurs.
10296    pub fn send_no_shutdown_on_err(
10297        self,
10298        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
10299    ) -> Result<(), fidl::Error> {
10300        let _result = self.send_raw(result);
10301        self.drop_without_shutdown();
10302        _result
10303    }
10304
10305    fn send_raw(
10306        &self,
10307        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
10308    ) -> Result<(), fidl::Error> {
10309        self.control_handle.inner.send::<fidl::encoding::ResultType<
10310            fidl_fuchsia_posix_socket::BaseSocketGetBroadcastResponse,
10311            fidl_fuchsia_posix::Errno,
10312        >>(
10313            result.map(|value| (value,)),
10314            self.tx_id,
10315            0x68796fc556f9780d,
10316            fidl::encoding::DynamicFlags::empty(),
10317        )
10318    }
10319}
10320
10321#[must_use = "FIDL methods require a response to be sent"]
10322#[derive(Debug)]
10323pub struct SocketSetSendBufferResponder {
10324    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
10325    tx_id: u32,
10326}
10327
10328/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
10329/// if the responder is dropped without sending a response, so that the client
10330/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
10331impl std::ops::Drop for SocketSetSendBufferResponder {
10332    fn drop(&mut self) {
10333        self.control_handle.shutdown();
10334        // Safety: drops once, never accessed again
10335        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10336    }
10337}
10338
10339impl fidl::endpoints::Responder for SocketSetSendBufferResponder {
10340    type ControlHandle = SocketControlHandle;
10341
10342    fn control_handle(&self) -> &SocketControlHandle {
10343        &self.control_handle
10344    }
10345
10346    fn drop_without_shutdown(mut self) {
10347        // Safety: drops once, never accessed again due to mem::forget
10348        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10349        // Prevent Drop from running (which would shut down the channel)
10350        std::mem::forget(self);
10351    }
10352}
10353
10354impl SocketSetSendBufferResponder {
10355    /// Sends a response to the FIDL transaction.
10356    ///
10357    /// Sets the channel to shutdown if an error occurs.
10358    pub fn send(
10359        self,
10360        mut result: Result<(), fidl_fuchsia_posix::Errno>,
10361    ) -> Result<(), fidl::Error> {
10362        let _result = self.send_raw(result);
10363        if _result.is_err() {
10364            self.control_handle.shutdown();
10365        }
10366        self.drop_without_shutdown();
10367        _result
10368    }
10369
10370    /// Similar to "send" but does not shutdown the channel if an error occurs.
10371    pub fn send_no_shutdown_on_err(
10372        self,
10373        mut result: Result<(), fidl_fuchsia_posix::Errno>,
10374    ) -> Result<(), fidl::Error> {
10375        let _result = self.send_raw(result);
10376        self.drop_without_shutdown();
10377        _result
10378    }
10379
10380    fn send_raw(
10381        &self,
10382        mut result: Result<(), fidl_fuchsia_posix::Errno>,
10383    ) -> Result<(), fidl::Error> {
10384        self.control_handle.inner.send::<fidl::encoding::ResultType<
10385            fidl::encoding::EmptyStruct,
10386            fidl_fuchsia_posix::Errno,
10387        >>(
10388            result,
10389            self.tx_id,
10390            0x756eac32d73a7a70,
10391            fidl::encoding::DynamicFlags::empty(),
10392        )
10393    }
10394}
10395
10396#[must_use = "FIDL methods require a response to be sent"]
10397#[derive(Debug)]
10398pub struct SocketGetSendBufferResponder {
10399    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
10400    tx_id: u32,
10401}
10402
10403/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
10404/// if the responder is dropped without sending a response, so that the client
10405/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
10406impl std::ops::Drop for SocketGetSendBufferResponder {
10407    fn drop(&mut self) {
10408        self.control_handle.shutdown();
10409        // Safety: drops once, never accessed again
10410        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10411    }
10412}
10413
10414impl fidl::endpoints::Responder for SocketGetSendBufferResponder {
10415    type ControlHandle = SocketControlHandle;
10416
10417    fn control_handle(&self) -> &SocketControlHandle {
10418        &self.control_handle
10419    }
10420
10421    fn drop_without_shutdown(mut self) {
10422        // Safety: drops once, never accessed again due to mem::forget
10423        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10424        // Prevent Drop from running (which would shut down the channel)
10425        std::mem::forget(self);
10426    }
10427}
10428
10429impl SocketGetSendBufferResponder {
10430    /// Sends a response to the FIDL transaction.
10431    ///
10432    /// Sets the channel to shutdown if an error occurs.
10433    pub fn send(
10434        self,
10435        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
10436    ) -> Result<(), fidl::Error> {
10437        let _result = self.send_raw(result);
10438        if _result.is_err() {
10439            self.control_handle.shutdown();
10440        }
10441        self.drop_without_shutdown();
10442        _result
10443    }
10444
10445    /// Similar to "send" but does not shutdown the channel if an error occurs.
10446    pub fn send_no_shutdown_on_err(
10447        self,
10448        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
10449    ) -> Result<(), fidl::Error> {
10450        let _result = self.send_raw(result);
10451        self.drop_without_shutdown();
10452        _result
10453    }
10454
10455    fn send_raw(
10456        &self,
10457        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
10458    ) -> Result<(), fidl::Error> {
10459        self.control_handle.inner.send::<fidl::encoding::ResultType<
10460            fidl_fuchsia_posix_socket::BaseSocketGetSendBufferResponse,
10461            fidl_fuchsia_posix::Errno,
10462        >>(
10463            result.map(|value_bytes| (value_bytes,)),
10464            self.tx_id,
10465            0x78a52fd9c7b2410b,
10466            fidl::encoding::DynamicFlags::empty(),
10467        )
10468    }
10469}
10470
10471#[must_use = "FIDL methods require a response to be sent"]
10472#[derive(Debug)]
10473pub struct SocketSetReceiveBufferResponder {
10474    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
10475    tx_id: u32,
10476}
10477
10478/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
10479/// if the responder is dropped without sending a response, so that the client
10480/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
10481impl std::ops::Drop for SocketSetReceiveBufferResponder {
10482    fn drop(&mut self) {
10483        self.control_handle.shutdown();
10484        // Safety: drops once, never accessed again
10485        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10486    }
10487}
10488
10489impl fidl::endpoints::Responder for SocketSetReceiveBufferResponder {
10490    type ControlHandle = SocketControlHandle;
10491
10492    fn control_handle(&self) -> &SocketControlHandle {
10493        &self.control_handle
10494    }
10495
10496    fn drop_without_shutdown(mut self) {
10497        // Safety: drops once, never accessed again due to mem::forget
10498        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10499        // Prevent Drop from running (which would shut down the channel)
10500        std::mem::forget(self);
10501    }
10502}
10503
10504impl SocketSetReceiveBufferResponder {
10505    /// Sends a response to the FIDL transaction.
10506    ///
10507    /// Sets the channel to shutdown if an error occurs.
10508    pub fn send(
10509        self,
10510        mut result: Result<(), fidl_fuchsia_posix::Errno>,
10511    ) -> Result<(), fidl::Error> {
10512        let _result = self.send_raw(result);
10513        if _result.is_err() {
10514            self.control_handle.shutdown();
10515        }
10516        self.drop_without_shutdown();
10517        _result
10518    }
10519
10520    /// Similar to "send" but does not shutdown the channel if an error occurs.
10521    pub fn send_no_shutdown_on_err(
10522        self,
10523        mut result: Result<(), fidl_fuchsia_posix::Errno>,
10524    ) -> Result<(), fidl::Error> {
10525        let _result = self.send_raw(result);
10526        self.drop_without_shutdown();
10527        _result
10528    }
10529
10530    fn send_raw(
10531        &self,
10532        mut result: Result<(), fidl_fuchsia_posix::Errno>,
10533    ) -> Result<(), fidl::Error> {
10534        self.control_handle.inner.send::<fidl::encoding::ResultType<
10535            fidl::encoding::EmptyStruct,
10536            fidl_fuchsia_posix::Errno,
10537        >>(
10538            result,
10539            self.tx_id,
10540            0x6b0cf2f1919c7001,
10541            fidl::encoding::DynamicFlags::empty(),
10542        )
10543    }
10544}
10545
10546#[must_use = "FIDL methods require a response to be sent"]
10547#[derive(Debug)]
10548pub struct SocketGetReceiveBufferResponder {
10549    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
10550    tx_id: u32,
10551}
10552
10553/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
10554/// if the responder is dropped without sending a response, so that the client
10555/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
10556impl std::ops::Drop for SocketGetReceiveBufferResponder {
10557    fn drop(&mut self) {
10558        self.control_handle.shutdown();
10559        // Safety: drops once, never accessed again
10560        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10561    }
10562}
10563
10564impl fidl::endpoints::Responder for SocketGetReceiveBufferResponder {
10565    type ControlHandle = SocketControlHandle;
10566
10567    fn control_handle(&self) -> &SocketControlHandle {
10568        &self.control_handle
10569    }
10570
10571    fn drop_without_shutdown(mut self) {
10572        // Safety: drops once, never accessed again due to mem::forget
10573        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10574        // Prevent Drop from running (which would shut down the channel)
10575        std::mem::forget(self);
10576    }
10577}
10578
10579impl SocketGetReceiveBufferResponder {
10580    /// Sends a response to the FIDL transaction.
10581    ///
10582    /// Sets the channel to shutdown if an error occurs.
10583    pub fn send(
10584        self,
10585        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
10586    ) -> Result<(), fidl::Error> {
10587        let _result = self.send_raw(result);
10588        if _result.is_err() {
10589            self.control_handle.shutdown();
10590        }
10591        self.drop_without_shutdown();
10592        _result
10593    }
10594
10595    /// Similar to "send" but does not shutdown the channel if an error occurs.
10596    pub fn send_no_shutdown_on_err(
10597        self,
10598        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
10599    ) -> Result<(), fidl::Error> {
10600        let _result = self.send_raw(result);
10601        self.drop_without_shutdown();
10602        _result
10603    }
10604
10605    fn send_raw(
10606        &self,
10607        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
10608    ) -> Result<(), fidl::Error> {
10609        self.control_handle.inner.send::<fidl::encoding::ResultType<
10610            fidl_fuchsia_posix_socket::BaseSocketGetReceiveBufferResponse,
10611            fidl_fuchsia_posix::Errno,
10612        >>(
10613            result.map(|value_bytes| (value_bytes,)),
10614            self.tx_id,
10615            0x14c1a4b64f709e5c,
10616            fidl::encoding::DynamicFlags::empty(),
10617        )
10618    }
10619}
10620
10621#[must_use = "FIDL methods require a response to be sent"]
10622#[derive(Debug)]
10623pub struct SocketSetKeepAliveResponder {
10624    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
10625    tx_id: u32,
10626}
10627
10628/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
10629/// if the responder is dropped without sending a response, so that the client
10630/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
10631impl std::ops::Drop for SocketSetKeepAliveResponder {
10632    fn drop(&mut self) {
10633        self.control_handle.shutdown();
10634        // Safety: drops once, never accessed again
10635        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10636    }
10637}
10638
10639impl fidl::endpoints::Responder for SocketSetKeepAliveResponder {
10640    type ControlHandle = SocketControlHandle;
10641
10642    fn control_handle(&self) -> &SocketControlHandle {
10643        &self.control_handle
10644    }
10645
10646    fn drop_without_shutdown(mut self) {
10647        // Safety: drops once, never accessed again due to mem::forget
10648        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10649        // Prevent Drop from running (which would shut down the channel)
10650        std::mem::forget(self);
10651    }
10652}
10653
10654impl SocketSetKeepAliveResponder {
10655    /// Sends a response to the FIDL transaction.
10656    ///
10657    /// Sets the channel to shutdown if an error occurs.
10658    pub fn send(
10659        self,
10660        mut result: Result<(), fidl_fuchsia_posix::Errno>,
10661    ) -> Result<(), fidl::Error> {
10662        let _result = self.send_raw(result);
10663        if _result.is_err() {
10664            self.control_handle.shutdown();
10665        }
10666        self.drop_without_shutdown();
10667        _result
10668    }
10669
10670    /// Similar to "send" but does not shutdown the channel if an error occurs.
10671    pub fn send_no_shutdown_on_err(
10672        self,
10673        mut result: Result<(), fidl_fuchsia_posix::Errno>,
10674    ) -> Result<(), fidl::Error> {
10675        let _result = self.send_raw(result);
10676        self.drop_without_shutdown();
10677        _result
10678    }
10679
10680    fn send_raw(
10681        &self,
10682        mut result: Result<(), fidl_fuchsia_posix::Errno>,
10683    ) -> Result<(), fidl::Error> {
10684        self.control_handle.inner.send::<fidl::encoding::ResultType<
10685            fidl::encoding::EmptyStruct,
10686            fidl_fuchsia_posix::Errno,
10687        >>(
10688            result,
10689            self.tx_id,
10690            0x572df8f0b920d2c7,
10691            fidl::encoding::DynamicFlags::empty(),
10692        )
10693    }
10694}
10695
10696#[must_use = "FIDL methods require a response to be sent"]
10697#[derive(Debug)]
10698pub struct SocketGetKeepAliveResponder {
10699    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
10700    tx_id: u32,
10701}
10702
10703/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
10704/// if the responder is dropped without sending a response, so that the client
10705/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
10706impl std::ops::Drop for SocketGetKeepAliveResponder {
10707    fn drop(&mut self) {
10708        self.control_handle.shutdown();
10709        // Safety: drops once, never accessed again
10710        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10711    }
10712}
10713
10714impl fidl::endpoints::Responder for SocketGetKeepAliveResponder {
10715    type ControlHandle = SocketControlHandle;
10716
10717    fn control_handle(&self) -> &SocketControlHandle {
10718        &self.control_handle
10719    }
10720
10721    fn drop_without_shutdown(mut self) {
10722        // Safety: drops once, never accessed again due to mem::forget
10723        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10724        // Prevent Drop from running (which would shut down the channel)
10725        std::mem::forget(self);
10726    }
10727}
10728
10729impl SocketGetKeepAliveResponder {
10730    /// Sends a response to the FIDL transaction.
10731    ///
10732    /// Sets the channel to shutdown if an error occurs.
10733    pub fn send(
10734        self,
10735        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
10736    ) -> Result<(), fidl::Error> {
10737        let _result = self.send_raw(result);
10738        if _result.is_err() {
10739            self.control_handle.shutdown();
10740        }
10741        self.drop_without_shutdown();
10742        _result
10743    }
10744
10745    /// Similar to "send" but does not shutdown the channel if an error occurs.
10746    pub fn send_no_shutdown_on_err(
10747        self,
10748        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
10749    ) -> Result<(), fidl::Error> {
10750        let _result = self.send_raw(result);
10751        self.drop_without_shutdown();
10752        _result
10753    }
10754
10755    fn send_raw(
10756        &self,
10757        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
10758    ) -> Result<(), fidl::Error> {
10759        self.control_handle.inner.send::<fidl::encoding::ResultType<
10760            fidl_fuchsia_posix_socket::BaseSocketGetKeepAliveResponse,
10761            fidl_fuchsia_posix::Errno,
10762        >>(
10763            result.map(|value| (value,)),
10764            self.tx_id,
10765            0x2dd29d3215f2c9d2,
10766            fidl::encoding::DynamicFlags::empty(),
10767        )
10768    }
10769}
10770
10771#[must_use = "FIDL methods require a response to be sent"]
10772#[derive(Debug)]
10773pub struct SocketSetOutOfBandInlineResponder {
10774    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
10775    tx_id: u32,
10776}
10777
10778/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
10779/// if the responder is dropped without sending a response, so that the client
10780/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
10781impl std::ops::Drop for SocketSetOutOfBandInlineResponder {
10782    fn drop(&mut self) {
10783        self.control_handle.shutdown();
10784        // Safety: drops once, never accessed again
10785        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10786    }
10787}
10788
10789impl fidl::endpoints::Responder for SocketSetOutOfBandInlineResponder {
10790    type ControlHandle = SocketControlHandle;
10791
10792    fn control_handle(&self) -> &SocketControlHandle {
10793        &self.control_handle
10794    }
10795
10796    fn drop_without_shutdown(mut self) {
10797        // Safety: drops once, never accessed again due to mem::forget
10798        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10799        // Prevent Drop from running (which would shut down the channel)
10800        std::mem::forget(self);
10801    }
10802}
10803
10804impl SocketSetOutOfBandInlineResponder {
10805    /// Sends a response to the FIDL transaction.
10806    ///
10807    /// Sets the channel to shutdown if an error occurs.
10808    pub fn send(
10809        self,
10810        mut result: Result<(), fidl_fuchsia_posix::Errno>,
10811    ) -> Result<(), fidl::Error> {
10812        let _result = self.send_raw(result);
10813        if _result.is_err() {
10814            self.control_handle.shutdown();
10815        }
10816        self.drop_without_shutdown();
10817        _result
10818    }
10819
10820    /// Similar to "send" but does not shutdown the channel if an error occurs.
10821    pub fn send_no_shutdown_on_err(
10822        self,
10823        mut result: Result<(), fidl_fuchsia_posix::Errno>,
10824    ) -> Result<(), fidl::Error> {
10825        let _result = self.send_raw(result);
10826        self.drop_without_shutdown();
10827        _result
10828    }
10829
10830    fn send_raw(
10831        &self,
10832        mut result: Result<(), fidl_fuchsia_posix::Errno>,
10833    ) -> Result<(), fidl::Error> {
10834        self.control_handle.inner.send::<fidl::encoding::ResultType<
10835            fidl::encoding::EmptyStruct,
10836            fidl_fuchsia_posix::Errno,
10837        >>(
10838            result,
10839            self.tx_id,
10840            0x3ecb49968bee439,
10841            fidl::encoding::DynamicFlags::empty(),
10842        )
10843    }
10844}
10845
10846#[must_use = "FIDL methods require a response to be sent"]
10847#[derive(Debug)]
10848pub struct SocketGetOutOfBandInlineResponder {
10849    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
10850    tx_id: u32,
10851}
10852
10853/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
10854/// if the responder is dropped without sending a response, so that the client
10855/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
10856impl std::ops::Drop for SocketGetOutOfBandInlineResponder {
10857    fn drop(&mut self) {
10858        self.control_handle.shutdown();
10859        // Safety: drops once, never accessed again
10860        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10861    }
10862}
10863
10864impl fidl::endpoints::Responder for SocketGetOutOfBandInlineResponder {
10865    type ControlHandle = SocketControlHandle;
10866
10867    fn control_handle(&self) -> &SocketControlHandle {
10868        &self.control_handle
10869    }
10870
10871    fn drop_without_shutdown(mut self) {
10872        // Safety: drops once, never accessed again due to mem::forget
10873        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10874        // Prevent Drop from running (which would shut down the channel)
10875        std::mem::forget(self);
10876    }
10877}
10878
10879impl SocketGetOutOfBandInlineResponder {
10880    /// Sends a response to the FIDL transaction.
10881    ///
10882    /// Sets the channel to shutdown if an error occurs.
10883    pub fn send(
10884        self,
10885        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
10886    ) -> Result<(), fidl::Error> {
10887        let _result = self.send_raw(result);
10888        if _result.is_err() {
10889            self.control_handle.shutdown();
10890        }
10891        self.drop_without_shutdown();
10892        _result
10893    }
10894
10895    /// Similar to "send" but does not shutdown the channel if an error occurs.
10896    pub fn send_no_shutdown_on_err(
10897        self,
10898        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
10899    ) -> Result<(), fidl::Error> {
10900        let _result = self.send_raw(result);
10901        self.drop_without_shutdown();
10902        _result
10903    }
10904
10905    fn send_raw(
10906        &self,
10907        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
10908    ) -> Result<(), fidl::Error> {
10909        self.control_handle.inner.send::<fidl::encoding::ResultType<
10910            fidl_fuchsia_posix_socket::BaseSocketGetOutOfBandInlineResponse,
10911            fidl_fuchsia_posix::Errno,
10912        >>(
10913            result.map(|value| (value,)),
10914            self.tx_id,
10915            0x348c1ab3aeca1745,
10916            fidl::encoding::DynamicFlags::empty(),
10917        )
10918    }
10919}
10920
10921#[must_use = "FIDL methods require a response to be sent"]
10922#[derive(Debug)]
10923pub struct SocketSetNoCheckResponder {
10924    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
10925    tx_id: u32,
10926}
10927
10928/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
10929/// if the responder is dropped without sending a response, so that the client
10930/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
10931impl std::ops::Drop for SocketSetNoCheckResponder {
10932    fn drop(&mut self) {
10933        self.control_handle.shutdown();
10934        // Safety: drops once, never accessed again
10935        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10936    }
10937}
10938
10939impl fidl::endpoints::Responder for SocketSetNoCheckResponder {
10940    type ControlHandle = SocketControlHandle;
10941
10942    fn control_handle(&self) -> &SocketControlHandle {
10943        &self.control_handle
10944    }
10945
10946    fn drop_without_shutdown(mut self) {
10947        // Safety: drops once, never accessed again due to mem::forget
10948        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10949        // Prevent Drop from running (which would shut down the channel)
10950        std::mem::forget(self);
10951    }
10952}
10953
10954impl SocketSetNoCheckResponder {
10955    /// Sends a response to the FIDL transaction.
10956    ///
10957    /// Sets the channel to shutdown if an error occurs.
10958    pub fn send(
10959        self,
10960        mut result: Result<(), fidl_fuchsia_posix::Errno>,
10961    ) -> Result<(), fidl::Error> {
10962        let _result = self.send_raw(result);
10963        if _result.is_err() {
10964            self.control_handle.shutdown();
10965        }
10966        self.drop_without_shutdown();
10967        _result
10968    }
10969
10970    /// Similar to "send" but does not shutdown the channel if an error occurs.
10971    pub fn send_no_shutdown_on_err(
10972        self,
10973        mut result: Result<(), fidl_fuchsia_posix::Errno>,
10974    ) -> Result<(), fidl::Error> {
10975        let _result = self.send_raw(result);
10976        self.drop_without_shutdown();
10977        _result
10978    }
10979
10980    fn send_raw(
10981        &self,
10982        mut result: Result<(), fidl_fuchsia_posix::Errno>,
10983    ) -> Result<(), fidl::Error> {
10984        self.control_handle.inner.send::<fidl::encoding::ResultType<
10985            fidl::encoding::EmptyStruct,
10986            fidl_fuchsia_posix::Errno,
10987        >>(
10988            result,
10989            self.tx_id,
10990            0x6bbf00c53a4c78c2,
10991            fidl::encoding::DynamicFlags::empty(),
10992        )
10993    }
10994}
10995
10996#[must_use = "FIDL methods require a response to be sent"]
10997#[derive(Debug)]
10998pub struct SocketGetNoCheckResponder {
10999    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
11000    tx_id: u32,
11001}
11002
11003/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
11004/// if the responder is dropped without sending a response, so that the client
11005/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
11006impl std::ops::Drop for SocketGetNoCheckResponder {
11007    fn drop(&mut self) {
11008        self.control_handle.shutdown();
11009        // Safety: drops once, never accessed again
11010        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11011    }
11012}
11013
11014impl fidl::endpoints::Responder for SocketGetNoCheckResponder {
11015    type ControlHandle = SocketControlHandle;
11016
11017    fn control_handle(&self) -> &SocketControlHandle {
11018        &self.control_handle
11019    }
11020
11021    fn drop_without_shutdown(mut self) {
11022        // Safety: drops once, never accessed again due to mem::forget
11023        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11024        // Prevent Drop from running (which would shut down the channel)
11025        std::mem::forget(self);
11026    }
11027}
11028
11029impl SocketGetNoCheckResponder {
11030    /// Sends a response to the FIDL transaction.
11031    ///
11032    /// Sets the channel to shutdown if an error occurs.
11033    pub fn send(
11034        self,
11035        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
11036    ) -> Result<(), fidl::Error> {
11037        let _result = self.send_raw(result);
11038        if _result.is_err() {
11039            self.control_handle.shutdown();
11040        }
11041        self.drop_without_shutdown();
11042        _result
11043    }
11044
11045    /// Similar to "send" but does not shutdown the channel if an error occurs.
11046    pub fn send_no_shutdown_on_err(
11047        self,
11048        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
11049    ) -> Result<(), fidl::Error> {
11050        let _result = self.send_raw(result);
11051        self.drop_without_shutdown();
11052        _result
11053    }
11054
11055    fn send_raw(
11056        &self,
11057        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
11058    ) -> Result<(), fidl::Error> {
11059        self.control_handle.inner.send::<fidl::encoding::ResultType<
11060            fidl_fuchsia_posix_socket::BaseSocketGetNoCheckResponse,
11061            fidl_fuchsia_posix::Errno,
11062        >>(
11063            result.map(|value| (value,)),
11064            self.tx_id,
11065            0x2cd4249286417694,
11066            fidl::encoding::DynamicFlags::empty(),
11067        )
11068    }
11069}
11070
11071#[must_use = "FIDL methods require a response to be sent"]
11072#[derive(Debug)]
11073pub struct SocketSetLingerResponder {
11074    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
11075    tx_id: u32,
11076}
11077
11078/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
11079/// if the responder is dropped without sending a response, so that the client
11080/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
11081impl std::ops::Drop for SocketSetLingerResponder {
11082    fn drop(&mut self) {
11083        self.control_handle.shutdown();
11084        // Safety: drops once, never accessed again
11085        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11086    }
11087}
11088
11089impl fidl::endpoints::Responder for SocketSetLingerResponder {
11090    type ControlHandle = SocketControlHandle;
11091
11092    fn control_handle(&self) -> &SocketControlHandle {
11093        &self.control_handle
11094    }
11095
11096    fn drop_without_shutdown(mut self) {
11097        // Safety: drops once, never accessed again due to mem::forget
11098        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11099        // Prevent Drop from running (which would shut down the channel)
11100        std::mem::forget(self);
11101    }
11102}
11103
11104impl SocketSetLingerResponder {
11105    /// Sends a response to the FIDL transaction.
11106    ///
11107    /// Sets the channel to shutdown if an error occurs.
11108    pub fn send(
11109        self,
11110        mut result: Result<(), fidl_fuchsia_posix::Errno>,
11111    ) -> Result<(), fidl::Error> {
11112        let _result = self.send_raw(result);
11113        if _result.is_err() {
11114            self.control_handle.shutdown();
11115        }
11116        self.drop_without_shutdown();
11117        _result
11118    }
11119
11120    /// Similar to "send" but does not shutdown the channel if an error occurs.
11121    pub fn send_no_shutdown_on_err(
11122        self,
11123        mut result: Result<(), fidl_fuchsia_posix::Errno>,
11124    ) -> Result<(), fidl::Error> {
11125        let _result = self.send_raw(result);
11126        self.drop_without_shutdown();
11127        _result
11128    }
11129
11130    fn send_raw(
11131        &self,
11132        mut result: Result<(), fidl_fuchsia_posix::Errno>,
11133    ) -> Result<(), fidl::Error> {
11134        self.control_handle.inner.send::<fidl::encoding::ResultType<
11135            fidl::encoding::EmptyStruct,
11136            fidl_fuchsia_posix::Errno,
11137        >>(
11138            result,
11139            self.tx_id,
11140            0x45386351246e998e,
11141            fidl::encoding::DynamicFlags::empty(),
11142        )
11143    }
11144}
11145
11146#[must_use = "FIDL methods require a response to be sent"]
11147#[derive(Debug)]
11148pub struct SocketGetLingerResponder {
11149    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
11150    tx_id: u32,
11151}
11152
11153/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
11154/// if the responder is dropped without sending a response, so that the client
11155/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
11156impl std::ops::Drop for SocketGetLingerResponder {
11157    fn drop(&mut self) {
11158        self.control_handle.shutdown();
11159        // Safety: drops once, never accessed again
11160        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11161    }
11162}
11163
11164impl fidl::endpoints::Responder for SocketGetLingerResponder {
11165    type ControlHandle = SocketControlHandle;
11166
11167    fn control_handle(&self) -> &SocketControlHandle {
11168        &self.control_handle
11169    }
11170
11171    fn drop_without_shutdown(mut self) {
11172        // Safety: drops once, never accessed again due to mem::forget
11173        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11174        // Prevent Drop from running (which would shut down the channel)
11175        std::mem::forget(self);
11176    }
11177}
11178
11179impl SocketGetLingerResponder {
11180    /// Sends a response to the FIDL transaction.
11181    ///
11182    /// Sets the channel to shutdown if an error occurs.
11183    pub fn send(
11184        self,
11185        mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
11186    ) -> Result<(), fidl::Error> {
11187        let _result = self.send_raw(result);
11188        if _result.is_err() {
11189            self.control_handle.shutdown();
11190        }
11191        self.drop_without_shutdown();
11192        _result
11193    }
11194
11195    /// Similar to "send" but does not shutdown the channel if an error occurs.
11196    pub fn send_no_shutdown_on_err(
11197        self,
11198        mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
11199    ) -> Result<(), fidl::Error> {
11200        let _result = self.send_raw(result);
11201        self.drop_without_shutdown();
11202        _result
11203    }
11204
11205    fn send_raw(
11206        &self,
11207        mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
11208    ) -> Result<(), fidl::Error> {
11209        self.control_handle.inner.send::<fidl::encoding::ResultType<
11210            fidl_fuchsia_posix_socket::BaseSocketGetLingerResponse,
11211            fidl_fuchsia_posix::Errno,
11212        >>(
11213            result,
11214            self.tx_id,
11215            0x48eb20fc5ccb0e45,
11216            fidl::encoding::DynamicFlags::empty(),
11217        )
11218    }
11219}
11220
11221#[must_use = "FIDL methods require a response to be sent"]
11222#[derive(Debug)]
11223pub struct SocketSetReusePortResponder {
11224    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
11225    tx_id: u32,
11226}
11227
11228/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
11229/// if the responder is dropped without sending a response, so that the client
11230/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
11231impl std::ops::Drop for SocketSetReusePortResponder {
11232    fn drop(&mut self) {
11233        self.control_handle.shutdown();
11234        // Safety: drops once, never accessed again
11235        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11236    }
11237}
11238
11239impl fidl::endpoints::Responder for SocketSetReusePortResponder {
11240    type ControlHandle = SocketControlHandle;
11241
11242    fn control_handle(&self) -> &SocketControlHandle {
11243        &self.control_handle
11244    }
11245
11246    fn drop_without_shutdown(mut self) {
11247        // Safety: drops once, never accessed again due to mem::forget
11248        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11249        // Prevent Drop from running (which would shut down the channel)
11250        std::mem::forget(self);
11251    }
11252}
11253
11254impl SocketSetReusePortResponder {
11255    /// Sends a response to the FIDL transaction.
11256    ///
11257    /// Sets the channel to shutdown if an error occurs.
11258    pub fn send(
11259        self,
11260        mut result: Result<(), fidl_fuchsia_posix::Errno>,
11261    ) -> Result<(), fidl::Error> {
11262        let _result = self.send_raw(result);
11263        if _result.is_err() {
11264            self.control_handle.shutdown();
11265        }
11266        self.drop_without_shutdown();
11267        _result
11268    }
11269
11270    /// Similar to "send" but does not shutdown the channel if an error occurs.
11271    pub fn send_no_shutdown_on_err(
11272        self,
11273        mut result: Result<(), fidl_fuchsia_posix::Errno>,
11274    ) -> Result<(), fidl::Error> {
11275        let _result = self.send_raw(result);
11276        self.drop_without_shutdown();
11277        _result
11278    }
11279
11280    fn send_raw(
11281        &self,
11282        mut result: Result<(), fidl_fuchsia_posix::Errno>,
11283    ) -> Result<(), fidl::Error> {
11284        self.control_handle.inner.send::<fidl::encoding::ResultType<
11285            fidl::encoding::EmptyStruct,
11286            fidl_fuchsia_posix::Errno,
11287        >>(
11288            result,
11289            self.tx_id,
11290            0x24dd3e5cb36d9ccb,
11291            fidl::encoding::DynamicFlags::empty(),
11292        )
11293    }
11294}
11295
11296#[must_use = "FIDL methods require a response to be sent"]
11297#[derive(Debug)]
11298pub struct SocketGetReusePortResponder {
11299    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
11300    tx_id: u32,
11301}
11302
11303/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
11304/// if the responder is dropped without sending a response, so that the client
11305/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
11306impl std::ops::Drop for SocketGetReusePortResponder {
11307    fn drop(&mut self) {
11308        self.control_handle.shutdown();
11309        // Safety: drops once, never accessed again
11310        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11311    }
11312}
11313
11314impl fidl::endpoints::Responder for SocketGetReusePortResponder {
11315    type ControlHandle = SocketControlHandle;
11316
11317    fn control_handle(&self) -> &SocketControlHandle {
11318        &self.control_handle
11319    }
11320
11321    fn drop_without_shutdown(mut self) {
11322        // Safety: drops once, never accessed again due to mem::forget
11323        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11324        // Prevent Drop from running (which would shut down the channel)
11325        std::mem::forget(self);
11326    }
11327}
11328
11329impl SocketGetReusePortResponder {
11330    /// Sends a response to the FIDL transaction.
11331    ///
11332    /// Sets the channel to shutdown if an error occurs.
11333    pub fn send(
11334        self,
11335        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
11336    ) -> Result<(), fidl::Error> {
11337        let _result = self.send_raw(result);
11338        if _result.is_err() {
11339            self.control_handle.shutdown();
11340        }
11341        self.drop_without_shutdown();
11342        _result
11343    }
11344
11345    /// Similar to "send" but does not shutdown the channel if an error occurs.
11346    pub fn send_no_shutdown_on_err(
11347        self,
11348        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
11349    ) -> Result<(), fidl::Error> {
11350        let _result = self.send_raw(result);
11351        self.drop_without_shutdown();
11352        _result
11353    }
11354
11355    fn send_raw(
11356        &self,
11357        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
11358    ) -> Result<(), fidl::Error> {
11359        self.control_handle.inner.send::<fidl::encoding::ResultType<
11360            fidl_fuchsia_posix_socket::BaseSocketGetReusePortResponse,
11361            fidl_fuchsia_posix::Errno,
11362        >>(
11363            result.map(|value| (value,)),
11364            self.tx_id,
11365            0x7a112c1ab54ff828,
11366            fidl::encoding::DynamicFlags::empty(),
11367        )
11368    }
11369}
11370
11371#[must_use = "FIDL methods require a response to be sent"]
11372#[derive(Debug)]
11373pub struct SocketGetAcceptConnResponder {
11374    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
11375    tx_id: u32,
11376}
11377
11378/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
11379/// if the responder is dropped without sending a response, so that the client
11380/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
11381impl std::ops::Drop for SocketGetAcceptConnResponder {
11382    fn drop(&mut self) {
11383        self.control_handle.shutdown();
11384        // Safety: drops once, never accessed again
11385        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11386    }
11387}
11388
11389impl fidl::endpoints::Responder for SocketGetAcceptConnResponder {
11390    type ControlHandle = SocketControlHandle;
11391
11392    fn control_handle(&self) -> &SocketControlHandle {
11393        &self.control_handle
11394    }
11395
11396    fn drop_without_shutdown(mut self) {
11397        // Safety: drops once, never accessed again due to mem::forget
11398        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11399        // Prevent Drop from running (which would shut down the channel)
11400        std::mem::forget(self);
11401    }
11402}
11403
11404impl SocketGetAcceptConnResponder {
11405    /// Sends a response to the FIDL transaction.
11406    ///
11407    /// Sets the channel to shutdown if an error occurs.
11408    pub fn send(
11409        self,
11410        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
11411    ) -> Result<(), fidl::Error> {
11412        let _result = self.send_raw(result);
11413        if _result.is_err() {
11414            self.control_handle.shutdown();
11415        }
11416        self.drop_without_shutdown();
11417        _result
11418    }
11419
11420    /// Similar to "send" but does not shutdown the channel if an error occurs.
11421    pub fn send_no_shutdown_on_err(
11422        self,
11423        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
11424    ) -> Result<(), fidl::Error> {
11425        let _result = self.send_raw(result);
11426        self.drop_without_shutdown();
11427        _result
11428    }
11429
11430    fn send_raw(
11431        &self,
11432        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
11433    ) -> Result<(), fidl::Error> {
11434        self.control_handle.inner.send::<fidl::encoding::ResultType<
11435            fidl_fuchsia_posix_socket::BaseSocketGetAcceptConnResponse,
11436            fidl_fuchsia_posix::Errno,
11437        >>(
11438            result.map(|value| (value,)),
11439            self.tx_id,
11440            0x67ce6db6c2ec8966,
11441            fidl::encoding::DynamicFlags::empty(),
11442        )
11443    }
11444}
11445
11446#[must_use = "FIDL methods require a response to be sent"]
11447#[derive(Debug)]
11448pub struct SocketSetBindToDeviceResponder {
11449    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
11450    tx_id: u32,
11451}
11452
11453/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
11454/// if the responder is dropped without sending a response, so that the client
11455/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
11456impl std::ops::Drop for SocketSetBindToDeviceResponder {
11457    fn drop(&mut self) {
11458        self.control_handle.shutdown();
11459        // Safety: drops once, never accessed again
11460        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11461    }
11462}
11463
11464impl fidl::endpoints::Responder for SocketSetBindToDeviceResponder {
11465    type ControlHandle = SocketControlHandle;
11466
11467    fn control_handle(&self) -> &SocketControlHandle {
11468        &self.control_handle
11469    }
11470
11471    fn drop_without_shutdown(mut self) {
11472        // Safety: drops once, never accessed again due to mem::forget
11473        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11474        // Prevent Drop from running (which would shut down the channel)
11475        std::mem::forget(self);
11476    }
11477}
11478
11479impl SocketSetBindToDeviceResponder {
11480    /// Sends a response to the FIDL transaction.
11481    ///
11482    /// Sets the channel to shutdown if an error occurs.
11483    pub fn send(
11484        self,
11485        mut result: Result<(), fidl_fuchsia_posix::Errno>,
11486    ) -> Result<(), fidl::Error> {
11487        let _result = self.send_raw(result);
11488        if _result.is_err() {
11489            self.control_handle.shutdown();
11490        }
11491        self.drop_without_shutdown();
11492        _result
11493    }
11494
11495    /// Similar to "send" but does not shutdown the channel if an error occurs.
11496    pub fn send_no_shutdown_on_err(
11497        self,
11498        mut result: Result<(), fidl_fuchsia_posix::Errno>,
11499    ) -> Result<(), fidl::Error> {
11500        let _result = self.send_raw(result);
11501        self.drop_without_shutdown();
11502        _result
11503    }
11504
11505    fn send_raw(
11506        &self,
11507        mut result: Result<(), fidl_fuchsia_posix::Errno>,
11508    ) -> Result<(), fidl::Error> {
11509        self.control_handle.inner.send::<fidl::encoding::ResultType<
11510            fidl::encoding::EmptyStruct,
11511            fidl_fuchsia_posix::Errno,
11512        >>(
11513            result,
11514            self.tx_id,
11515            0x2118b483f28aafc4,
11516            fidl::encoding::DynamicFlags::empty(),
11517        )
11518    }
11519}
11520
11521#[must_use = "FIDL methods require a response to be sent"]
11522#[derive(Debug)]
11523pub struct SocketGetBindToDeviceResponder {
11524    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
11525    tx_id: u32,
11526}
11527
11528/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
11529/// if the responder is dropped without sending a response, so that the client
11530/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
11531impl std::ops::Drop for SocketGetBindToDeviceResponder {
11532    fn drop(&mut self) {
11533        self.control_handle.shutdown();
11534        // Safety: drops once, never accessed again
11535        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11536    }
11537}
11538
11539impl fidl::endpoints::Responder for SocketGetBindToDeviceResponder {
11540    type ControlHandle = SocketControlHandle;
11541
11542    fn control_handle(&self) -> &SocketControlHandle {
11543        &self.control_handle
11544    }
11545
11546    fn drop_without_shutdown(mut self) {
11547        // Safety: drops once, never accessed again due to mem::forget
11548        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11549        // Prevent Drop from running (which would shut down the channel)
11550        std::mem::forget(self);
11551    }
11552}
11553
11554impl SocketGetBindToDeviceResponder {
11555    /// Sends a response to the FIDL transaction.
11556    ///
11557    /// Sets the channel to shutdown if an error occurs.
11558    pub fn send(
11559        self,
11560        mut result: Result<&str, fidl_fuchsia_posix::Errno>,
11561    ) -> Result<(), fidl::Error> {
11562        let _result = self.send_raw(result);
11563        if _result.is_err() {
11564            self.control_handle.shutdown();
11565        }
11566        self.drop_without_shutdown();
11567        _result
11568    }
11569
11570    /// Similar to "send" but does not shutdown the channel if an error occurs.
11571    pub fn send_no_shutdown_on_err(
11572        self,
11573        mut result: Result<&str, fidl_fuchsia_posix::Errno>,
11574    ) -> Result<(), fidl::Error> {
11575        let _result = self.send_raw(result);
11576        self.drop_without_shutdown();
11577        _result
11578    }
11579
11580    fn send_raw(
11581        &self,
11582        mut result: Result<&str, fidl_fuchsia_posix::Errno>,
11583    ) -> Result<(), fidl::Error> {
11584        self.control_handle.inner.send::<fidl::encoding::ResultType<
11585            fidl_fuchsia_posix_socket::BaseSocketGetBindToDeviceResponse,
11586            fidl_fuchsia_posix::Errno,
11587        >>(
11588            result.map(|value| (value,)),
11589            self.tx_id,
11590            0x1ab1fbf0ef7906c8,
11591            fidl::encoding::DynamicFlags::empty(),
11592        )
11593    }
11594}
11595
11596#[must_use = "FIDL methods require a response to be sent"]
11597#[derive(Debug)]
11598pub struct SocketSetBindToInterfaceIndexResponder {
11599    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
11600    tx_id: u32,
11601}
11602
11603/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
11604/// if the responder is dropped without sending a response, so that the client
11605/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
11606impl std::ops::Drop for SocketSetBindToInterfaceIndexResponder {
11607    fn drop(&mut self) {
11608        self.control_handle.shutdown();
11609        // Safety: drops once, never accessed again
11610        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11611    }
11612}
11613
11614impl fidl::endpoints::Responder for SocketSetBindToInterfaceIndexResponder {
11615    type ControlHandle = SocketControlHandle;
11616
11617    fn control_handle(&self) -> &SocketControlHandle {
11618        &self.control_handle
11619    }
11620
11621    fn drop_without_shutdown(mut self) {
11622        // Safety: drops once, never accessed again due to mem::forget
11623        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11624        // Prevent Drop from running (which would shut down the channel)
11625        std::mem::forget(self);
11626    }
11627}
11628
11629impl SocketSetBindToInterfaceIndexResponder {
11630    /// Sends a response to the FIDL transaction.
11631    ///
11632    /// Sets the channel to shutdown if an error occurs.
11633    pub fn send(
11634        self,
11635        mut result: Result<(), fidl_fuchsia_posix::Errno>,
11636    ) -> Result<(), fidl::Error> {
11637        let _result = self.send_raw(result);
11638        if _result.is_err() {
11639            self.control_handle.shutdown();
11640        }
11641        self.drop_without_shutdown();
11642        _result
11643    }
11644
11645    /// Similar to "send" but does not shutdown the channel if an error occurs.
11646    pub fn send_no_shutdown_on_err(
11647        self,
11648        mut result: Result<(), fidl_fuchsia_posix::Errno>,
11649    ) -> Result<(), fidl::Error> {
11650        let _result = self.send_raw(result);
11651        self.drop_without_shutdown();
11652        _result
11653    }
11654
11655    fn send_raw(
11656        &self,
11657        mut result: Result<(), fidl_fuchsia_posix::Errno>,
11658    ) -> Result<(), fidl::Error> {
11659        self.control_handle.inner.send::<fidl::encoding::ResultType<
11660            fidl::encoding::EmptyStruct,
11661            fidl_fuchsia_posix::Errno,
11662        >>(
11663            result,
11664            self.tx_id,
11665            0x6e387a0def00821,
11666            fidl::encoding::DynamicFlags::empty(),
11667        )
11668    }
11669}
11670
11671#[must_use = "FIDL methods require a response to be sent"]
11672#[derive(Debug)]
11673pub struct SocketGetBindToInterfaceIndexResponder {
11674    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
11675    tx_id: u32,
11676}
11677
11678/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
11679/// if the responder is dropped without sending a response, so that the client
11680/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
11681impl std::ops::Drop for SocketGetBindToInterfaceIndexResponder {
11682    fn drop(&mut self) {
11683        self.control_handle.shutdown();
11684        // Safety: drops once, never accessed again
11685        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11686    }
11687}
11688
11689impl fidl::endpoints::Responder for SocketGetBindToInterfaceIndexResponder {
11690    type ControlHandle = SocketControlHandle;
11691
11692    fn control_handle(&self) -> &SocketControlHandle {
11693        &self.control_handle
11694    }
11695
11696    fn drop_without_shutdown(mut self) {
11697        // Safety: drops once, never accessed again due to mem::forget
11698        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11699        // Prevent Drop from running (which would shut down the channel)
11700        std::mem::forget(self);
11701    }
11702}
11703
11704impl SocketGetBindToInterfaceIndexResponder {
11705    /// Sends a response to the FIDL transaction.
11706    ///
11707    /// Sets the channel to shutdown if an error occurs.
11708    pub fn send(
11709        self,
11710        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
11711    ) -> Result<(), fidl::Error> {
11712        let _result = self.send_raw(result);
11713        if _result.is_err() {
11714            self.control_handle.shutdown();
11715        }
11716        self.drop_without_shutdown();
11717        _result
11718    }
11719
11720    /// Similar to "send" but does not shutdown the channel if an error occurs.
11721    pub fn send_no_shutdown_on_err(
11722        self,
11723        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
11724    ) -> Result<(), fidl::Error> {
11725        let _result = self.send_raw(result);
11726        self.drop_without_shutdown();
11727        _result
11728    }
11729
11730    fn send_raw(
11731        &self,
11732        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
11733    ) -> Result<(), fidl::Error> {
11734        self.control_handle.inner.send::<fidl::encoding::ResultType<
11735            fidl_fuchsia_posix_socket::BaseSocketGetBindToInterfaceIndexResponse,
11736            fidl_fuchsia_posix::Errno,
11737        >>(
11738            result.map(|value| (value,)),
11739            self.tx_id,
11740            0x59c31dd3e3078295,
11741            fidl::encoding::DynamicFlags::empty(),
11742        )
11743    }
11744}
11745
11746#[must_use = "FIDL methods require a response to be sent"]
11747#[derive(Debug)]
11748pub struct SocketSetTimestampResponder {
11749    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
11750    tx_id: u32,
11751}
11752
11753/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
11754/// if the responder is dropped without sending a response, so that the client
11755/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
11756impl std::ops::Drop for SocketSetTimestampResponder {
11757    fn drop(&mut self) {
11758        self.control_handle.shutdown();
11759        // Safety: drops once, never accessed again
11760        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11761    }
11762}
11763
11764impl fidl::endpoints::Responder for SocketSetTimestampResponder {
11765    type ControlHandle = SocketControlHandle;
11766
11767    fn control_handle(&self) -> &SocketControlHandle {
11768        &self.control_handle
11769    }
11770
11771    fn drop_without_shutdown(mut self) {
11772        // Safety: drops once, never accessed again due to mem::forget
11773        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11774        // Prevent Drop from running (which would shut down the channel)
11775        std::mem::forget(self);
11776    }
11777}
11778
11779impl SocketSetTimestampResponder {
11780    /// Sends a response to the FIDL transaction.
11781    ///
11782    /// Sets the channel to shutdown if an error occurs.
11783    pub fn send(
11784        self,
11785        mut result: Result<(), fidl_fuchsia_posix::Errno>,
11786    ) -> Result<(), fidl::Error> {
11787        let _result = self.send_raw(result);
11788        if _result.is_err() {
11789            self.control_handle.shutdown();
11790        }
11791        self.drop_without_shutdown();
11792        _result
11793    }
11794
11795    /// Similar to "send" but does not shutdown the channel if an error occurs.
11796    pub fn send_no_shutdown_on_err(
11797        self,
11798        mut result: Result<(), fidl_fuchsia_posix::Errno>,
11799    ) -> Result<(), fidl::Error> {
11800        let _result = self.send_raw(result);
11801        self.drop_without_shutdown();
11802        _result
11803    }
11804
11805    fn send_raw(
11806        &self,
11807        mut result: Result<(), fidl_fuchsia_posix::Errno>,
11808    ) -> Result<(), fidl::Error> {
11809        self.control_handle.inner.send::<fidl::encoding::ResultType<
11810            fidl::encoding::EmptyStruct,
11811            fidl_fuchsia_posix::Errno,
11812        >>(
11813            result,
11814            self.tx_id,
11815            0x285d6516c263d839,
11816            fidl::encoding::DynamicFlags::empty(),
11817        )
11818    }
11819}
11820
11821#[must_use = "FIDL methods require a response to be sent"]
11822#[derive(Debug)]
11823pub struct SocketGetTimestampResponder {
11824    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
11825    tx_id: u32,
11826}
11827
11828/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
11829/// if the responder is dropped without sending a response, so that the client
11830/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
11831impl std::ops::Drop for SocketGetTimestampResponder {
11832    fn drop(&mut self) {
11833        self.control_handle.shutdown();
11834        // Safety: drops once, never accessed again
11835        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11836    }
11837}
11838
11839impl fidl::endpoints::Responder for SocketGetTimestampResponder {
11840    type ControlHandle = SocketControlHandle;
11841
11842    fn control_handle(&self) -> &SocketControlHandle {
11843        &self.control_handle
11844    }
11845
11846    fn drop_without_shutdown(mut self) {
11847        // Safety: drops once, never accessed again due to mem::forget
11848        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11849        // Prevent Drop from running (which would shut down the channel)
11850        std::mem::forget(self);
11851    }
11852}
11853
11854impl SocketGetTimestampResponder {
11855    /// Sends a response to the FIDL transaction.
11856    ///
11857    /// Sets the channel to shutdown if an error occurs.
11858    pub fn send(
11859        self,
11860        mut result: Result<fidl_fuchsia_posix_socket::TimestampOption, fidl_fuchsia_posix::Errno>,
11861    ) -> Result<(), fidl::Error> {
11862        let _result = self.send_raw(result);
11863        if _result.is_err() {
11864            self.control_handle.shutdown();
11865        }
11866        self.drop_without_shutdown();
11867        _result
11868    }
11869
11870    /// Similar to "send" but does not shutdown the channel if an error occurs.
11871    pub fn send_no_shutdown_on_err(
11872        self,
11873        mut result: Result<fidl_fuchsia_posix_socket::TimestampOption, fidl_fuchsia_posix::Errno>,
11874    ) -> Result<(), fidl::Error> {
11875        let _result = self.send_raw(result);
11876        self.drop_without_shutdown();
11877        _result
11878    }
11879
11880    fn send_raw(
11881        &self,
11882        mut result: Result<fidl_fuchsia_posix_socket::TimestampOption, fidl_fuchsia_posix::Errno>,
11883    ) -> Result<(), fidl::Error> {
11884        self.control_handle.inner.send::<fidl::encoding::ResultType<
11885            fidl_fuchsia_posix_socket::BaseSocketGetTimestampResponse,
11886            fidl_fuchsia_posix::Errno,
11887        >>(
11888            result.map(|value| (value,)),
11889            self.tx_id,
11890            0x49f2fffbbcc2bd27,
11891            fidl::encoding::DynamicFlags::empty(),
11892        )
11893    }
11894}
11895
11896#[must_use = "FIDL methods require a response to be sent"]
11897#[derive(Debug)]
11898pub struct SocketSetMarkResponder {
11899    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
11900    tx_id: u32,
11901}
11902
11903/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
11904/// if the responder is dropped without sending a response, so that the client
11905/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
11906impl std::ops::Drop for SocketSetMarkResponder {
11907    fn drop(&mut self) {
11908        self.control_handle.shutdown();
11909        // Safety: drops once, never accessed again
11910        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11911    }
11912}
11913
11914impl fidl::endpoints::Responder for SocketSetMarkResponder {
11915    type ControlHandle = SocketControlHandle;
11916
11917    fn control_handle(&self) -> &SocketControlHandle {
11918        &self.control_handle
11919    }
11920
11921    fn drop_without_shutdown(mut self) {
11922        // Safety: drops once, never accessed again due to mem::forget
11923        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11924        // Prevent Drop from running (which would shut down the channel)
11925        std::mem::forget(self);
11926    }
11927}
11928
11929impl SocketSetMarkResponder {
11930    /// Sends a response to the FIDL transaction.
11931    ///
11932    /// Sets the channel to shutdown if an error occurs.
11933    pub fn send(
11934        self,
11935        mut result: Result<(), fidl_fuchsia_posix::Errno>,
11936    ) -> Result<(), fidl::Error> {
11937        let _result = self.send_raw(result);
11938        if _result.is_err() {
11939            self.control_handle.shutdown();
11940        }
11941        self.drop_without_shutdown();
11942        _result
11943    }
11944
11945    /// Similar to "send" but does not shutdown the channel if an error occurs.
11946    pub fn send_no_shutdown_on_err(
11947        self,
11948        mut result: Result<(), fidl_fuchsia_posix::Errno>,
11949    ) -> Result<(), fidl::Error> {
11950        let _result = self.send_raw(result);
11951        self.drop_without_shutdown();
11952        _result
11953    }
11954
11955    fn send_raw(
11956        &self,
11957        mut result: Result<(), fidl_fuchsia_posix::Errno>,
11958    ) -> Result<(), fidl::Error> {
11959        self.control_handle.inner.send::<fidl::encoding::ResultType<
11960            fidl::encoding::EmptyStruct,
11961            fidl_fuchsia_posix::Errno,
11962        >>(
11963            result,
11964            self.tx_id,
11965            0x6ead6de09f653236,
11966            fidl::encoding::DynamicFlags::empty(),
11967        )
11968    }
11969}
11970
11971#[must_use = "FIDL methods require a response to be sent"]
11972#[derive(Debug)]
11973pub struct SocketGetMarkResponder {
11974    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
11975    tx_id: u32,
11976}
11977
11978/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
11979/// if the responder is dropped without sending a response, so that the client
11980/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
11981impl std::ops::Drop for SocketGetMarkResponder {
11982    fn drop(&mut self) {
11983        self.control_handle.shutdown();
11984        // Safety: drops once, never accessed again
11985        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11986    }
11987}
11988
11989impl fidl::endpoints::Responder for SocketGetMarkResponder {
11990    type ControlHandle = SocketControlHandle;
11991
11992    fn control_handle(&self) -> &SocketControlHandle {
11993        &self.control_handle
11994    }
11995
11996    fn drop_without_shutdown(mut self) {
11997        // Safety: drops once, never accessed again due to mem::forget
11998        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11999        // Prevent Drop from running (which would shut down the channel)
12000        std::mem::forget(self);
12001    }
12002}
12003
12004impl SocketGetMarkResponder {
12005    /// Sends a response to the FIDL transaction.
12006    ///
12007    /// Sets the channel to shutdown if an error occurs.
12008    pub fn send(
12009        self,
12010        mut result: Result<&fidl_fuchsia_posix_socket::OptionalUint32, fidl_fuchsia_posix::Errno>,
12011    ) -> Result<(), fidl::Error> {
12012        let _result = self.send_raw(result);
12013        if _result.is_err() {
12014            self.control_handle.shutdown();
12015        }
12016        self.drop_without_shutdown();
12017        _result
12018    }
12019
12020    /// Similar to "send" but does not shutdown the channel if an error occurs.
12021    pub fn send_no_shutdown_on_err(
12022        self,
12023        mut result: Result<&fidl_fuchsia_posix_socket::OptionalUint32, fidl_fuchsia_posix::Errno>,
12024    ) -> Result<(), fidl::Error> {
12025        let _result = self.send_raw(result);
12026        self.drop_without_shutdown();
12027        _result
12028    }
12029
12030    fn send_raw(
12031        &self,
12032        mut result: Result<&fidl_fuchsia_posix_socket::OptionalUint32, fidl_fuchsia_posix::Errno>,
12033    ) -> Result<(), fidl::Error> {
12034        self.control_handle.inner.send::<fidl::encoding::ResultType<
12035            fidl_fuchsia_posix_socket::BaseSocketGetMarkResponse,
12036            fidl_fuchsia_posix::Errno,
12037        >>(
12038            result.map(|mark| (mark,)),
12039            self.tx_id,
12040            0x57a2752c61d93d47,
12041            fidl::encoding::DynamicFlags::empty(),
12042        )
12043    }
12044}
12045
12046#[must_use = "FIDL methods require a response to be sent"]
12047#[derive(Debug)]
12048pub struct SocketGetCookieResponder {
12049    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
12050    tx_id: u32,
12051}
12052
12053/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
12054/// if the responder is dropped without sending a response, so that the client
12055/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
12056impl std::ops::Drop for SocketGetCookieResponder {
12057    fn drop(&mut self) {
12058        self.control_handle.shutdown();
12059        // Safety: drops once, never accessed again
12060        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12061    }
12062}
12063
12064impl fidl::endpoints::Responder for SocketGetCookieResponder {
12065    type ControlHandle = SocketControlHandle;
12066
12067    fn control_handle(&self) -> &SocketControlHandle {
12068        &self.control_handle
12069    }
12070
12071    fn drop_without_shutdown(mut self) {
12072        // Safety: drops once, never accessed again due to mem::forget
12073        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12074        // Prevent Drop from running (which would shut down the channel)
12075        std::mem::forget(self);
12076    }
12077}
12078
12079impl SocketGetCookieResponder {
12080    /// Sends a response to the FIDL transaction.
12081    ///
12082    /// Sets the channel to shutdown if an error occurs.
12083    pub fn send(
12084        self,
12085        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
12086    ) -> Result<(), fidl::Error> {
12087        let _result = self.send_raw(result);
12088        if _result.is_err() {
12089            self.control_handle.shutdown();
12090        }
12091        self.drop_without_shutdown();
12092        _result
12093    }
12094
12095    /// Similar to "send" but does not shutdown the channel if an error occurs.
12096    pub fn send_no_shutdown_on_err(
12097        self,
12098        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
12099    ) -> Result<(), fidl::Error> {
12100        let _result = self.send_raw(result);
12101        self.drop_without_shutdown();
12102        _result
12103    }
12104
12105    fn send_raw(
12106        &self,
12107        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
12108    ) -> Result<(), fidl::Error> {
12109        self.control_handle.inner.send::<fidl::encoding::ResultType<
12110            fidl_fuchsia_posix_socket::BaseSocketGetCookieResponse,
12111            fidl_fuchsia_posix::Errno,
12112        >>(
12113            result.map(|value| (value,)),
12114            self.tx_id,
12115            0x2c2f47fd8f924e52,
12116            fidl::encoding::DynamicFlags::empty(),
12117        )
12118    }
12119}
12120
12121#[must_use = "FIDL methods require a response to be sent"]
12122#[derive(Debug)]
12123pub struct SocketBindResponder {
12124    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
12125    tx_id: u32,
12126}
12127
12128/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
12129/// if the responder is dropped without sending a response, so that the client
12130/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
12131impl std::ops::Drop for SocketBindResponder {
12132    fn drop(&mut self) {
12133        self.control_handle.shutdown();
12134        // Safety: drops once, never accessed again
12135        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12136    }
12137}
12138
12139impl fidl::endpoints::Responder for SocketBindResponder {
12140    type ControlHandle = SocketControlHandle;
12141
12142    fn control_handle(&self) -> &SocketControlHandle {
12143        &self.control_handle
12144    }
12145
12146    fn drop_without_shutdown(mut self) {
12147        // Safety: drops once, never accessed again due to mem::forget
12148        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12149        // Prevent Drop from running (which would shut down the channel)
12150        std::mem::forget(self);
12151    }
12152}
12153
12154impl SocketBindResponder {
12155    /// Sends a response to the FIDL transaction.
12156    ///
12157    /// Sets the channel to shutdown if an error occurs.
12158    pub fn send(
12159        self,
12160        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12161    ) -> Result<(), fidl::Error> {
12162        let _result = self.send_raw(result);
12163        if _result.is_err() {
12164            self.control_handle.shutdown();
12165        }
12166        self.drop_without_shutdown();
12167        _result
12168    }
12169
12170    /// Similar to "send" but does not shutdown the channel if an error occurs.
12171    pub fn send_no_shutdown_on_err(
12172        self,
12173        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12174    ) -> Result<(), fidl::Error> {
12175        let _result = self.send_raw(result);
12176        self.drop_without_shutdown();
12177        _result
12178    }
12179
12180    fn send_raw(
12181        &self,
12182        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12183    ) -> Result<(), fidl::Error> {
12184        self.control_handle.inner.send::<fidl::encoding::ResultType<
12185            fidl::encoding::EmptyStruct,
12186            fidl_fuchsia_posix::Errno,
12187        >>(
12188            result,
12189            self.tx_id,
12190            0x4bc6400ae92125d,
12191            fidl::encoding::DynamicFlags::empty(),
12192        )
12193    }
12194}
12195
12196#[must_use = "FIDL methods require a response to be sent"]
12197#[derive(Debug)]
12198pub struct SocketConnectResponder {
12199    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
12200    tx_id: u32,
12201}
12202
12203/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
12204/// if the responder is dropped without sending a response, so that the client
12205/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
12206impl std::ops::Drop for SocketConnectResponder {
12207    fn drop(&mut self) {
12208        self.control_handle.shutdown();
12209        // Safety: drops once, never accessed again
12210        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12211    }
12212}
12213
12214impl fidl::endpoints::Responder for SocketConnectResponder {
12215    type ControlHandle = SocketControlHandle;
12216
12217    fn control_handle(&self) -> &SocketControlHandle {
12218        &self.control_handle
12219    }
12220
12221    fn drop_without_shutdown(mut self) {
12222        // Safety: drops once, never accessed again due to mem::forget
12223        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12224        // Prevent Drop from running (which would shut down the channel)
12225        std::mem::forget(self);
12226    }
12227}
12228
12229impl SocketConnectResponder {
12230    /// Sends a response to the FIDL transaction.
12231    ///
12232    /// Sets the channel to shutdown if an error occurs.
12233    pub fn send(
12234        self,
12235        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12236    ) -> Result<(), fidl::Error> {
12237        let _result = self.send_raw(result);
12238        if _result.is_err() {
12239            self.control_handle.shutdown();
12240        }
12241        self.drop_without_shutdown();
12242        _result
12243    }
12244
12245    /// Similar to "send" but does not shutdown the channel if an error occurs.
12246    pub fn send_no_shutdown_on_err(
12247        self,
12248        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12249    ) -> Result<(), fidl::Error> {
12250        let _result = self.send_raw(result);
12251        self.drop_without_shutdown();
12252        _result
12253    }
12254
12255    fn send_raw(
12256        &self,
12257        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12258    ) -> Result<(), fidl::Error> {
12259        self.control_handle.inner.send::<fidl::encoding::ResultType<
12260            fidl::encoding::EmptyStruct,
12261            fidl_fuchsia_posix::Errno,
12262        >>(
12263            result,
12264            self.tx_id,
12265            0x5f05f19bfdd38871,
12266            fidl::encoding::DynamicFlags::empty(),
12267        )
12268    }
12269}
12270
12271#[must_use = "FIDL methods require a response to be sent"]
12272#[derive(Debug)]
12273pub struct SocketDisconnectResponder {
12274    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
12275    tx_id: u32,
12276}
12277
12278/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
12279/// if the responder is dropped without sending a response, so that the client
12280/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
12281impl std::ops::Drop for SocketDisconnectResponder {
12282    fn drop(&mut self) {
12283        self.control_handle.shutdown();
12284        // Safety: drops once, never accessed again
12285        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12286    }
12287}
12288
12289impl fidl::endpoints::Responder for SocketDisconnectResponder {
12290    type ControlHandle = SocketControlHandle;
12291
12292    fn control_handle(&self) -> &SocketControlHandle {
12293        &self.control_handle
12294    }
12295
12296    fn drop_without_shutdown(mut self) {
12297        // Safety: drops once, never accessed again due to mem::forget
12298        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12299        // Prevent Drop from running (which would shut down the channel)
12300        std::mem::forget(self);
12301    }
12302}
12303
12304impl SocketDisconnectResponder {
12305    /// Sends a response to the FIDL transaction.
12306    ///
12307    /// Sets the channel to shutdown if an error occurs.
12308    pub fn send(
12309        self,
12310        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12311    ) -> Result<(), fidl::Error> {
12312        let _result = self.send_raw(result);
12313        if _result.is_err() {
12314            self.control_handle.shutdown();
12315        }
12316        self.drop_without_shutdown();
12317        _result
12318    }
12319
12320    /// Similar to "send" but does not shutdown the channel if an error occurs.
12321    pub fn send_no_shutdown_on_err(
12322        self,
12323        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12324    ) -> Result<(), fidl::Error> {
12325        let _result = self.send_raw(result);
12326        self.drop_without_shutdown();
12327        _result
12328    }
12329
12330    fn send_raw(
12331        &self,
12332        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12333    ) -> Result<(), fidl::Error> {
12334        self.control_handle.inner.send::<fidl::encoding::ResultType<
12335            fidl::encoding::EmptyStruct,
12336            fidl_fuchsia_posix::Errno,
12337        >>(
12338            result,
12339            self.tx_id,
12340            0x74e63b91f7b29b2,
12341            fidl::encoding::DynamicFlags::empty(),
12342        )
12343    }
12344}
12345
12346#[must_use = "FIDL methods require a response to be sent"]
12347#[derive(Debug)]
12348pub struct SocketGetSockNameResponder {
12349    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
12350    tx_id: u32,
12351}
12352
12353/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
12354/// if the responder is dropped without sending a response, so that the client
12355/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
12356impl std::ops::Drop for SocketGetSockNameResponder {
12357    fn drop(&mut self) {
12358        self.control_handle.shutdown();
12359        // Safety: drops once, never accessed again
12360        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12361    }
12362}
12363
12364impl fidl::endpoints::Responder for SocketGetSockNameResponder {
12365    type ControlHandle = SocketControlHandle;
12366
12367    fn control_handle(&self) -> &SocketControlHandle {
12368        &self.control_handle
12369    }
12370
12371    fn drop_without_shutdown(mut self) {
12372        // Safety: drops once, never accessed again due to mem::forget
12373        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12374        // Prevent Drop from running (which would shut down the channel)
12375        std::mem::forget(self);
12376    }
12377}
12378
12379impl SocketGetSockNameResponder {
12380    /// Sends a response to the FIDL transaction.
12381    ///
12382    /// Sets the channel to shutdown if an error occurs.
12383    pub fn send(
12384        self,
12385        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
12386    ) -> Result<(), fidl::Error> {
12387        let _result = self.send_raw(result);
12388        if _result.is_err() {
12389            self.control_handle.shutdown();
12390        }
12391        self.drop_without_shutdown();
12392        _result
12393    }
12394
12395    /// Similar to "send" but does not shutdown the channel if an error occurs.
12396    pub fn send_no_shutdown_on_err(
12397        self,
12398        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
12399    ) -> Result<(), fidl::Error> {
12400        let _result = self.send_raw(result);
12401        self.drop_without_shutdown();
12402        _result
12403    }
12404
12405    fn send_raw(
12406        &self,
12407        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
12408    ) -> Result<(), fidl::Error> {
12409        self.control_handle.inner.send::<fidl::encoding::ResultType<
12410            fidl_fuchsia_posix_socket::BaseNetworkSocketGetSockNameResponse,
12411            fidl_fuchsia_posix::Errno,
12412        >>(
12413            result.map(|addr| (addr,)),
12414            self.tx_id,
12415            0x475f23f84a1a4f85,
12416            fidl::encoding::DynamicFlags::empty(),
12417        )
12418    }
12419}
12420
12421#[must_use = "FIDL methods require a response to be sent"]
12422#[derive(Debug)]
12423pub struct SocketGetPeerNameResponder {
12424    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
12425    tx_id: u32,
12426}
12427
12428/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
12429/// if the responder is dropped without sending a response, so that the client
12430/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
12431impl std::ops::Drop for SocketGetPeerNameResponder {
12432    fn drop(&mut self) {
12433        self.control_handle.shutdown();
12434        // Safety: drops once, never accessed again
12435        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12436    }
12437}
12438
12439impl fidl::endpoints::Responder for SocketGetPeerNameResponder {
12440    type ControlHandle = SocketControlHandle;
12441
12442    fn control_handle(&self) -> &SocketControlHandle {
12443        &self.control_handle
12444    }
12445
12446    fn drop_without_shutdown(mut self) {
12447        // Safety: drops once, never accessed again due to mem::forget
12448        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12449        // Prevent Drop from running (which would shut down the channel)
12450        std::mem::forget(self);
12451    }
12452}
12453
12454impl SocketGetPeerNameResponder {
12455    /// Sends a response to the FIDL transaction.
12456    ///
12457    /// Sets the channel to shutdown if an error occurs.
12458    pub fn send(
12459        self,
12460        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
12461    ) -> Result<(), fidl::Error> {
12462        let _result = self.send_raw(result);
12463        if _result.is_err() {
12464            self.control_handle.shutdown();
12465        }
12466        self.drop_without_shutdown();
12467        _result
12468    }
12469
12470    /// Similar to "send" but does not shutdown the channel if an error occurs.
12471    pub fn send_no_shutdown_on_err(
12472        self,
12473        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
12474    ) -> Result<(), fidl::Error> {
12475        let _result = self.send_raw(result);
12476        self.drop_without_shutdown();
12477        _result
12478    }
12479
12480    fn send_raw(
12481        &self,
12482        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
12483    ) -> Result<(), fidl::Error> {
12484        self.control_handle.inner.send::<fidl::encoding::ResultType<
12485            fidl_fuchsia_posix_socket::BaseNetworkSocketGetPeerNameResponse,
12486            fidl_fuchsia_posix::Errno,
12487        >>(
12488            result.map(|addr| (addr,)),
12489            self.tx_id,
12490            0x1ffecf4bd5b6432e,
12491            fidl::encoding::DynamicFlags::empty(),
12492        )
12493    }
12494}
12495
12496#[must_use = "FIDL methods require a response to be sent"]
12497#[derive(Debug)]
12498pub struct SocketShutdownResponder {
12499    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
12500    tx_id: u32,
12501}
12502
12503/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
12504/// if the responder is dropped without sending a response, so that the client
12505/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
12506impl std::ops::Drop for SocketShutdownResponder {
12507    fn drop(&mut self) {
12508        self.control_handle.shutdown();
12509        // Safety: drops once, never accessed again
12510        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12511    }
12512}
12513
12514impl fidl::endpoints::Responder for SocketShutdownResponder {
12515    type ControlHandle = SocketControlHandle;
12516
12517    fn control_handle(&self) -> &SocketControlHandle {
12518        &self.control_handle
12519    }
12520
12521    fn drop_without_shutdown(mut self) {
12522        // Safety: drops once, never accessed again due to mem::forget
12523        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12524        // Prevent Drop from running (which would shut down the channel)
12525        std::mem::forget(self);
12526    }
12527}
12528
12529impl SocketShutdownResponder {
12530    /// Sends a response to the FIDL transaction.
12531    ///
12532    /// Sets the channel to shutdown if an error occurs.
12533    pub fn send(
12534        self,
12535        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12536    ) -> Result<(), fidl::Error> {
12537        let _result = self.send_raw(result);
12538        if _result.is_err() {
12539            self.control_handle.shutdown();
12540        }
12541        self.drop_without_shutdown();
12542        _result
12543    }
12544
12545    /// Similar to "send" but does not shutdown the channel if an error occurs.
12546    pub fn send_no_shutdown_on_err(
12547        self,
12548        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12549    ) -> Result<(), fidl::Error> {
12550        let _result = self.send_raw(result);
12551        self.drop_without_shutdown();
12552        _result
12553    }
12554
12555    fn send_raw(
12556        &self,
12557        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12558    ) -> Result<(), fidl::Error> {
12559        self.control_handle.inner.send::<fidl::encoding::ResultType<
12560            fidl::encoding::EmptyStruct,
12561            fidl_fuchsia_posix::Errno,
12562        >>(
12563            result,
12564            self.tx_id,
12565            0x247f38b6db68c336,
12566            fidl::encoding::DynamicFlags::empty(),
12567        )
12568    }
12569}
12570
12571#[must_use = "FIDL methods require a response to be sent"]
12572#[derive(Debug)]
12573pub struct SocketSetIpTypeOfServiceResponder {
12574    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
12575    tx_id: u32,
12576}
12577
12578/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
12579/// if the responder is dropped without sending a response, so that the client
12580/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
12581impl std::ops::Drop for SocketSetIpTypeOfServiceResponder {
12582    fn drop(&mut self) {
12583        self.control_handle.shutdown();
12584        // Safety: drops once, never accessed again
12585        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12586    }
12587}
12588
12589impl fidl::endpoints::Responder for SocketSetIpTypeOfServiceResponder {
12590    type ControlHandle = SocketControlHandle;
12591
12592    fn control_handle(&self) -> &SocketControlHandle {
12593        &self.control_handle
12594    }
12595
12596    fn drop_without_shutdown(mut self) {
12597        // Safety: drops once, never accessed again due to mem::forget
12598        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12599        // Prevent Drop from running (which would shut down the channel)
12600        std::mem::forget(self);
12601    }
12602}
12603
12604impl SocketSetIpTypeOfServiceResponder {
12605    /// Sends a response to the FIDL transaction.
12606    ///
12607    /// Sets the channel to shutdown if an error occurs.
12608    pub fn send(
12609        self,
12610        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12611    ) -> Result<(), fidl::Error> {
12612        let _result = self.send_raw(result);
12613        if _result.is_err() {
12614            self.control_handle.shutdown();
12615        }
12616        self.drop_without_shutdown();
12617        _result
12618    }
12619
12620    /// Similar to "send" but does not shutdown the channel if an error occurs.
12621    pub fn send_no_shutdown_on_err(
12622        self,
12623        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12624    ) -> Result<(), fidl::Error> {
12625        let _result = self.send_raw(result);
12626        self.drop_without_shutdown();
12627        _result
12628    }
12629
12630    fn send_raw(
12631        &self,
12632        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12633    ) -> Result<(), fidl::Error> {
12634        self.control_handle.inner.send::<fidl::encoding::ResultType<
12635            fidl::encoding::EmptyStruct,
12636            fidl_fuchsia_posix::Errno,
12637        >>(
12638            result,
12639            self.tx_id,
12640            0x995c600475b6d46,
12641            fidl::encoding::DynamicFlags::empty(),
12642        )
12643    }
12644}
12645
12646#[must_use = "FIDL methods require a response to be sent"]
12647#[derive(Debug)]
12648pub struct SocketGetIpTypeOfServiceResponder {
12649    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
12650    tx_id: u32,
12651}
12652
12653/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
12654/// if the responder is dropped without sending a response, so that the client
12655/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
12656impl std::ops::Drop for SocketGetIpTypeOfServiceResponder {
12657    fn drop(&mut self) {
12658        self.control_handle.shutdown();
12659        // Safety: drops once, never accessed again
12660        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12661    }
12662}
12663
12664impl fidl::endpoints::Responder for SocketGetIpTypeOfServiceResponder {
12665    type ControlHandle = SocketControlHandle;
12666
12667    fn control_handle(&self) -> &SocketControlHandle {
12668        &self.control_handle
12669    }
12670
12671    fn drop_without_shutdown(mut self) {
12672        // Safety: drops once, never accessed again due to mem::forget
12673        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12674        // Prevent Drop from running (which would shut down the channel)
12675        std::mem::forget(self);
12676    }
12677}
12678
12679impl SocketGetIpTypeOfServiceResponder {
12680    /// Sends a response to the FIDL transaction.
12681    ///
12682    /// Sets the channel to shutdown if an error occurs.
12683    pub fn send(
12684        self,
12685        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
12686    ) -> Result<(), fidl::Error> {
12687        let _result = self.send_raw(result);
12688        if _result.is_err() {
12689            self.control_handle.shutdown();
12690        }
12691        self.drop_without_shutdown();
12692        _result
12693    }
12694
12695    /// Similar to "send" but does not shutdown the channel if an error occurs.
12696    pub fn send_no_shutdown_on_err(
12697        self,
12698        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
12699    ) -> Result<(), fidl::Error> {
12700        let _result = self.send_raw(result);
12701        self.drop_without_shutdown();
12702        _result
12703    }
12704
12705    fn send_raw(
12706        &self,
12707        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
12708    ) -> Result<(), fidl::Error> {
12709        self.control_handle.inner.send::<fidl::encoding::ResultType<
12710            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTypeOfServiceResponse,
12711            fidl_fuchsia_posix::Errno,
12712        >>(
12713            result.map(|value| (value,)),
12714            self.tx_id,
12715            0x3814a04259f75fcb,
12716            fidl::encoding::DynamicFlags::empty(),
12717        )
12718    }
12719}
12720
12721#[must_use = "FIDL methods require a response to be sent"]
12722#[derive(Debug)]
12723pub struct SocketSetIpTtlResponder {
12724    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
12725    tx_id: u32,
12726}
12727
12728/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
12729/// if the responder is dropped without sending a response, so that the client
12730/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
12731impl std::ops::Drop for SocketSetIpTtlResponder {
12732    fn drop(&mut self) {
12733        self.control_handle.shutdown();
12734        // Safety: drops once, never accessed again
12735        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12736    }
12737}
12738
12739impl fidl::endpoints::Responder for SocketSetIpTtlResponder {
12740    type ControlHandle = SocketControlHandle;
12741
12742    fn control_handle(&self) -> &SocketControlHandle {
12743        &self.control_handle
12744    }
12745
12746    fn drop_without_shutdown(mut self) {
12747        // Safety: drops once, never accessed again due to mem::forget
12748        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12749        // Prevent Drop from running (which would shut down the channel)
12750        std::mem::forget(self);
12751    }
12752}
12753
12754impl SocketSetIpTtlResponder {
12755    /// Sends a response to the FIDL transaction.
12756    ///
12757    /// Sets the channel to shutdown if an error occurs.
12758    pub fn send(
12759        self,
12760        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12761    ) -> Result<(), fidl::Error> {
12762        let _result = self.send_raw(result);
12763        if _result.is_err() {
12764            self.control_handle.shutdown();
12765        }
12766        self.drop_without_shutdown();
12767        _result
12768    }
12769
12770    /// Similar to "send" but does not shutdown the channel if an error occurs.
12771    pub fn send_no_shutdown_on_err(
12772        self,
12773        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12774    ) -> Result<(), fidl::Error> {
12775        let _result = self.send_raw(result);
12776        self.drop_without_shutdown();
12777        _result
12778    }
12779
12780    fn send_raw(
12781        &self,
12782        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12783    ) -> Result<(), fidl::Error> {
12784        self.control_handle.inner.send::<fidl::encoding::ResultType<
12785            fidl::encoding::EmptyStruct,
12786            fidl_fuchsia_posix::Errno,
12787        >>(
12788            result,
12789            self.tx_id,
12790            0x29e2424b433ae1ef,
12791            fidl::encoding::DynamicFlags::empty(),
12792        )
12793    }
12794}
12795
12796#[must_use = "FIDL methods require a response to be sent"]
12797#[derive(Debug)]
12798pub struct SocketGetIpTtlResponder {
12799    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
12800    tx_id: u32,
12801}
12802
12803/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
12804/// if the responder is dropped without sending a response, so that the client
12805/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
12806impl std::ops::Drop for SocketGetIpTtlResponder {
12807    fn drop(&mut self) {
12808        self.control_handle.shutdown();
12809        // Safety: drops once, never accessed again
12810        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12811    }
12812}
12813
12814impl fidl::endpoints::Responder for SocketGetIpTtlResponder {
12815    type ControlHandle = SocketControlHandle;
12816
12817    fn control_handle(&self) -> &SocketControlHandle {
12818        &self.control_handle
12819    }
12820
12821    fn drop_without_shutdown(mut self) {
12822        // Safety: drops once, never accessed again due to mem::forget
12823        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12824        // Prevent Drop from running (which would shut down the channel)
12825        std::mem::forget(self);
12826    }
12827}
12828
12829impl SocketGetIpTtlResponder {
12830    /// Sends a response to the FIDL transaction.
12831    ///
12832    /// Sets the channel to shutdown if an error occurs.
12833    pub fn send(
12834        self,
12835        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
12836    ) -> Result<(), fidl::Error> {
12837        let _result = self.send_raw(result);
12838        if _result.is_err() {
12839            self.control_handle.shutdown();
12840        }
12841        self.drop_without_shutdown();
12842        _result
12843    }
12844
12845    /// Similar to "send" but does not shutdown the channel if an error occurs.
12846    pub fn send_no_shutdown_on_err(
12847        self,
12848        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
12849    ) -> Result<(), fidl::Error> {
12850        let _result = self.send_raw(result);
12851        self.drop_without_shutdown();
12852        _result
12853    }
12854
12855    fn send_raw(
12856        &self,
12857        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
12858    ) -> Result<(), fidl::Error> {
12859        self.control_handle.inner.send::<fidl::encoding::ResultType<
12860            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTtlResponse,
12861            fidl_fuchsia_posix::Errno,
12862        >>(
12863            result.map(|value| (value,)),
12864            self.tx_id,
12865            0x47e47fa1f24da471,
12866            fidl::encoding::DynamicFlags::empty(),
12867        )
12868    }
12869}
12870
12871#[must_use = "FIDL methods require a response to be sent"]
12872#[derive(Debug)]
12873pub struct SocketSetIpPacketInfoResponder {
12874    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
12875    tx_id: u32,
12876}
12877
12878/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
12879/// if the responder is dropped without sending a response, so that the client
12880/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
12881impl std::ops::Drop for SocketSetIpPacketInfoResponder {
12882    fn drop(&mut self) {
12883        self.control_handle.shutdown();
12884        // Safety: drops once, never accessed again
12885        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12886    }
12887}
12888
12889impl fidl::endpoints::Responder for SocketSetIpPacketInfoResponder {
12890    type ControlHandle = SocketControlHandle;
12891
12892    fn control_handle(&self) -> &SocketControlHandle {
12893        &self.control_handle
12894    }
12895
12896    fn drop_without_shutdown(mut self) {
12897        // Safety: drops once, never accessed again due to mem::forget
12898        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12899        // Prevent Drop from running (which would shut down the channel)
12900        std::mem::forget(self);
12901    }
12902}
12903
12904impl SocketSetIpPacketInfoResponder {
12905    /// Sends a response to the FIDL transaction.
12906    ///
12907    /// Sets the channel to shutdown if an error occurs.
12908    pub fn send(
12909        self,
12910        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12911    ) -> Result<(), fidl::Error> {
12912        let _result = self.send_raw(result);
12913        if _result.is_err() {
12914            self.control_handle.shutdown();
12915        }
12916        self.drop_without_shutdown();
12917        _result
12918    }
12919
12920    /// Similar to "send" but does not shutdown the channel if an error occurs.
12921    pub fn send_no_shutdown_on_err(
12922        self,
12923        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12924    ) -> Result<(), fidl::Error> {
12925        let _result = self.send_raw(result);
12926        self.drop_without_shutdown();
12927        _result
12928    }
12929
12930    fn send_raw(
12931        &self,
12932        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12933    ) -> Result<(), fidl::Error> {
12934        self.control_handle.inner.send::<fidl::encoding::ResultType<
12935            fidl::encoding::EmptyStruct,
12936            fidl_fuchsia_posix::Errno,
12937        >>(
12938            result,
12939            self.tx_id,
12940            0x392d16bee20c0e16,
12941            fidl::encoding::DynamicFlags::empty(),
12942        )
12943    }
12944}
12945
12946#[must_use = "FIDL methods require a response to be sent"]
12947#[derive(Debug)]
12948pub struct SocketGetIpPacketInfoResponder {
12949    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
12950    tx_id: u32,
12951}
12952
12953/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
12954/// if the responder is dropped without sending a response, so that the client
12955/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
12956impl std::ops::Drop for SocketGetIpPacketInfoResponder {
12957    fn drop(&mut self) {
12958        self.control_handle.shutdown();
12959        // Safety: drops once, never accessed again
12960        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12961    }
12962}
12963
12964impl fidl::endpoints::Responder for SocketGetIpPacketInfoResponder {
12965    type ControlHandle = SocketControlHandle;
12966
12967    fn control_handle(&self) -> &SocketControlHandle {
12968        &self.control_handle
12969    }
12970
12971    fn drop_without_shutdown(mut self) {
12972        // Safety: drops once, never accessed again due to mem::forget
12973        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12974        // Prevent Drop from running (which would shut down the channel)
12975        std::mem::forget(self);
12976    }
12977}
12978
12979impl SocketGetIpPacketInfoResponder {
12980    /// Sends a response to the FIDL transaction.
12981    ///
12982    /// Sets the channel to shutdown if an error occurs.
12983    pub fn send(
12984        self,
12985        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
12986    ) -> Result<(), fidl::Error> {
12987        let _result = self.send_raw(result);
12988        if _result.is_err() {
12989            self.control_handle.shutdown();
12990        }
12991        self.drop_without_shutdown();
12992        _result
12993    }
12994
12995    /// Similar to "send" but does not shutdown the channel if an error occurs.
12996    pub fn send_no_shutdown_on_err(
12997        self,
12998        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
12999    ) -> Result<(), fidl::Error> {
13000        let _result = self.send_raw(result);
13001        self.drop_without_shutdown();
13002        _result
13003    }
13004
13005    fn send_raw(
13006        &self,
13007        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13008    ) -> Result<(), fidl::Error> {
13009        self.control_handle.inner.send::<fidl::encoding::ResultType<
13010            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpPacketInfoResponse,
13011            fidl_fuchsia_posix::Errno,
13012        >>(
13013            result.map(|value| (value,)),
13014            self.tx_id,
13015            0x54b505f242280740,
13016            fidl::encoding::DynamicFlags::empty(),
13017        )
13018    }
13019}
13020
13021#[must_use = "FIDL methods require a response to be sent"]
13022#[derive(Debug)]
13023pub struct SocketSetIpReceiveTypeOfServiceResponder {
13024    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
13025    tx_id: u32,
13026}
13027
13028/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
13029/// if the responder is dropped without sending a response, so that the client
13030/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
13031impl std::ops::Drop for SocketSetIpReceiveTypeOfServiceResponder {
13032    fn drop(&mut self) {
13033        self.control_handle.shutdown();
13034        // Safety: drops once, never accessed again
13035        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13036    }
13037}
13038
13039impl fidl::endpoints::Responder for SocketSetIpReceiveTypeOfServiceResponder {
13040    type ControlHandle = SocketControlHandle;
13041
13042    fn control_handle(&self) -> &SocketControlHandle {
13043        &self.control_handle
13044    }
13045
13046    fn drop_without_shutdown(mut self) {
13047        // Safety: drops once, never accessed again due to mem::forget
13048        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13049        // Prevent Drop from running (which would shut down the channel)
13050        std::mem::forget(self);
13051    }
13052}
13053
13054impl SocketSetIpReceiveTypeOfServiceResponder {
13055    /// Sends a response to the FIDL transaction.
13056    ///
13057    /// Sets the channel to shutdown if an error occurs.
13058    pub fn send(
13059        self,
13060        mut result: Result<(), fidl_fuchsia_posix::Errno>,
13061    ) -> Result<(), fidl::Error> {
13062        let _result = self.send_raw(result);
13063        if _result.is_err() {
13064            self.control_handle.shutdown();
13065        }
13066        self.drop_without_shutdown();
13067        _result
13068    }
13069
13070    /// Similar to "send" but does not shutdown the channel if an error occurs.
13071    pub fn send_no_shutdown_on_err(
13072        self,
13073        mut result: Result<(), fidl_fuchsia_posix::Errno>,
13074    ) -> Result<(), fidl::Error> {
13075        let _result = self.send_raw(result);
13076        self.drop_without_shutdown();
13077        _result
13078    }
13079
13080    fn send_raw(
13081        &self,
13082        mut result: Result<(), fidl_fuchsia_posix::Errno>,
13083    ) -> Result<(), fidl::Error> {
13084        self.control_handle.inner.send::<fidl::encoding::ResultType<
13085            fidl::encoding::EmptyStruct,
13086            fidl_fuchsia_posix::Errno,
13087        >>(
13088            result,
13089            self.tx_id,
13090            0x6c4f6714995f84ef,
13091            fidl::encoding::DynamicFlags::empty(),
13092        )
13093    }
13094}
13095
13096#[must_use = "FIDL methods require a response to be sent"]
13097#[derive(Debug)]
13098pub struct SocketGetIpReceiveTypeOfServiceResponder {
13099    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
13100    tx_id: u32,
13101}
13102
13103/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
13104/// if the responder is dropped without sending a response, so that the client
13105/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
13106impl std::ops::Drop for SocketGetIpReceiveTypeOfServiceResponder {
13107    fn drop(&mut self) {
13108        self.control_handle.shutdown();
13109        // Safety: drops once, never accessed again
13110        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13111    }
13112}
13113
13114impl fidl::endpoints::Responder for SocketGetIpReceiveTypeOfServiceResponder {
13115    type ControlHandle = SocketControlHandle;
13116
13117    fn control_handle(&self) -> &SocketControlHandle {
13118        &self.control_handle
13119    }
13120
13121    fn drop_without_shutdown(mut self) {
13122        // Safety: drops once, never accessed again due to mem::forget
13123        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13124        // Prevent Drop from running (which would shut down the channel)
13125        std::mem::forget(self);
13126    }
13127}
13128
13129impl SocketGetIpReceiveTypeOfServiceResponder {
13130    /// Sends a response to the FIDL transaction.
13131    ///
13132    /// Sets the channel to shutdown if an error occurs.
13133    pub fn send(
13134        self,
13135        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13136    ) -> Result<(), fidl::Error> {
13137        let _result = self.send_raw(result);
13138        if _result.is_err() {
13139            self.control_handle.shutdown();
13140        }
13141        self.drop_without_shutdown();
13142        _result
13143    }
13144
13145    /// Similar to "send" but does not shutdown the channel if an error occurs.
13146    pub fn send_no_shutdown_on_err(
13147        self,
13148        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13149    ) -> Result<(), fidl::Error> {
13150        let _result = self.send_raw(result);
13151        self.drop_without_shutdown();
13152        _result
13153    }
13154
13155    fn send_raw(
13156        &self,
13157        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13158    ) -> Result<(), fidl::Error> {
13159        self.control_handle.inner.send::<fidl::encoding::ResultType<
13160            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
13161            fidl_fuchsia_posix::Errno,
13162        >>(
13163            result.map(|value| (value,)),
13164            self.tx_id,
13165            0x4158ba7dc2795960,
13166            fidl::encoding::DynamicFlags::empty(),
13167        )
13168    }
13169}
13170
13171#[must_use = "FIDL methods require a response to be sent"]
13172#[derive(Debug)]
13173pub struct SocketSetIpReceiveTtlResponder {
13174    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
13175    tx_id: u32,
13176}
13177
13178/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
13179/// if the responder is dropped without sending a response, so that the client
13180/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
13181impl std::ops::Drop for SocketSetIpReceiveTtlResponder {
13182    fn drop(&mut self) {
13183        self.control_handle.shutdown();
13184        // Safety: drops once, never accessed again
13185        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13186    }
13187}
13188
13189impl fidl::endpoints::Responder for SocketSetIpReceiveTtlResponder {
13190    type ControlHandle = SocketControlHandle;
13191
13192    fn control_handle(&self) -> &SocketControlHandle {
13193        &self.control_handle
13194    }
13195
13196    fn drop_without_shutdown(mut self) {
13197        // Safety: drops once, never accessed again due to mem::forget
13198        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13199        // Prevent Drop from running (which would shut down the channel)
13200        std::mem::forget(self);
13201    }
13202}
13203
13204impl SocketSetIpReceiveTtlResponder {
13205    /// Sends a response to the FIDL transaction.
13206    ///
13207    /// Sets the channel to shutdown if an error occurs.
13208    pub fn send(
13209        self,
13210        mut result: Result<(), fidl_fuchsia_posix::Errno>,
13211    ) -> Result<(), fidl::Error> {
13212        let _result = self.send_raw(result);
13213        if _result.is_err() {
13214            self.control_handle.shutdown();
13215        }
13216        self.drop_without_shutdown();
13217        _result
13218    }
13219
13220    /// Similar to "send" but does not shutdown the channel if an error occurs.
13221    pub fn send_no_shutdown_on_err(
13222        self,
13223        mut result: Result<(), fidl_fuchsia_posix::Errno>,
13224    ) -> Result<(), fidl::Error> {
13225        let _result = self.send_raw(result);
13226        self.drop_without_shutdown();
13227        _result
13228    }
13229
13230    fn send_raw(
13231        &self,
13232        mut result: Result<(), fidl_fuchsia_posix::Errno>,
13233    ) -> Result<(), fidl::Error> {
13234        self.control_handle.inner.send::<fidl::encoding::ResultType<
13235            fidl::encoding::EmptyStruct,
13236            fidl_fuchsia_posix::Errno,
13237        >>(
13238            result,
13239            self.tx_id,
13240            0x46f15be0ce0ab82b,
13241            fidl::encoding::DynamicFlags::empty(),
13242        )
13243    }
13244}
13245
13246#[must_use = "FIDL methods require a response to be sent"]
13247#[derive(Debug)]
13248pub struct SocketGetIpReceiveTtlResponder {
13249    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
13250    tx_id: u32,
13251}
13252
13253/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
13254/// if the responder is dropped without sending a response, so that the client
13255/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
13256impl std::ops::Drop for SocketGetIpReceiveTtlResponder {
13257    fn drop(&mut self) {
13258        self.control_handle.shutdown();
13259        // Safety: drops once, never accessed again
13260        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13261    }
13262}
13263
13264impl fidl::endpoints::Responder for SocketGetIpReceiveTtlResponder {
13265    type ControlHandle = SocketControlHandle;
13266
13267    fn control_handle(&self) -> &SocketControlHandle {
13268        &self.control_handle
13269    }
13270
13271    fn drop_without_shutdown(mut self) {
13272        // Safety: drops once, never accessed again due to mem::forget
13273        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13274        // Prevent Drop from running (which would shut down the channel)
13275        std::mem::forget(self);
13276    }
13277}
13278
13279impl SocketGetIpReceiveTtlResponder {
13280    /// Sends a response to the FIDL transaction.
13281    ///
13282    /// Sets the channel to shutdown if an error occurs.
13283    pub fn send(
13284        self,
13285        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13286    ) -> Result<(), fidl::Error> {
13287        let _result = self.send_raw(result);
13288        if _result.is_err() {
13289            self.control_handle.shutdown();
13290        }
13291        self.drop_without_shutdown();
13292        _result
13293    }
13294
13295    /// Similar to "send" but does not shutdown the channel if an error occurs.
13296    pub fn send_no_shutdown_on_err(
13297        self,
13298        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13299    ) -> Result<(), fidl::Error> {
13300        let _result = self.send_raw(result);
13301        self.drop_without_shutdown();
13302        _result
13303    }
13304
13305    fn send_raw(
13306        &self,
13307        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13308    ) -> Result<(), fidl::Error> {
13309        self.control_handle.inner.send::<fidl::encoding::ResultType<
13310            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveTtlResponse,
13311            fidl_fuchsia_posix::Errno,
13312        >>(
13313            result.map(|value| (value,)),
13314            self.tx_id,
13315            0x678ddd5a5dfa2eb5,
13316            fidl::encoding::DynamicFlags::empty(),
13317        )
13318    }
13319}
13320
13321#[must_use = "FIDL methods require a response to be sent"]
13322#[derive(Debug)]
13323pub struct SocketSetIpMulticastInterfaceResponder {
13324    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
13325    tx_id: u32,
13326}
13327
13328/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
13329/// if the responder is dropped without sending a response, so that the client
13330/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
13331impl std::ops::Drop for SocketSetIpMulticastInterfaceResponder {
13332    fn drop(&mut self) {
13333        self.control_handle.shutdown();
13334        // Safety: drops once, never accessed again
13335        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13336    }
13337}
13338
13339impl fidl::endpoints::Responder for SocketSetIpMulticastInterfaceResponder {
13340    type ControlHandle = SocketControlHandle;
13341
13342    fn control_handle(&self) -> &SocketControlHandle {
13343        &self.control_handle
13344    }
13345
13346    fn drop_without_shutdown(mut self) {
13347        // Safety: drops once, never accessed again due to mem::forget
13348        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13349        // Prevent Drop from running (which would shut down the channel)
13350        std::mem::forget(self);
13351    }
13352}
13353
13354impl SocketSetIpMulticastInterfaceResponder {
13355    /// Sends a response to the FIDL transaction.
13356    ///
13357    /// Sets the channel to shutdown if an error occurs.
13358    pub fn send(
13359        self,
13360        mut result: Result<(), fidl_fuchsia_posix::Errno>,
13361    ) -> Result<(), fidl::Error> {
13362        let _result = self.send_raw(result);
13363        if _result.is_err() {
13364            self.control_handle.shutdown();
13365        }
13366        self.drop_without_shutdown();
13367        _result
13368    }
13369
13370    /// Similar to "send" but does not shutdown the channel if an error occurs.
13371    pub fn send_no_shutdown_on_err(
13372        self,
13373        mut result: Result<(), fidl_fuchsia_posix::Errno>,
13374    ) -> Result<(), fidl::Error> {
13375        let _result = self.send_raw(result);
13376        self.drop_without_shutdown();
13377        _result
13378    }
13379
13380    fn send_raw(
13381        &self,
13382        mut result: Result<(), fidl_fuchsia_posix::Errno>,
13383    ) -> Result<(), fidl::Error> {
13384        self.control_handle.inner.send::<fidl::encoding::ResultType<
13385            fidl::encoding::EmptyStruct,
13386            fidl_fuchsia_posix::Errno,
13387        >>(
13388            result,
13389            self.tx_id,
13390            0x752fbfa9b12befe,
13391            fidl::encoding::DynamicFlags::empty(),
13392        )
13393    }
13394}
13395
13396#[must_use = "FIDL methods require a response to be sent"]
13397#[derive(Debug)]
13398pub struct SocketGetIpMulticastInterfaceResponder {
13399    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
13400    tx_id: u32,
13401}
13402
13403/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
13404/// if the responder is dropped without sending a response, so that the client
13405/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
13406impl std::ops::Drop for SocketGetIpMulticastInterfaceResponder {
13407    fn drop(&mut self) {
13408        self.control_handle.shutdown();
13409        // Safety: drops once, never accessed again
13410        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13411    }
13412}
13413
13414impl fidl::endpoints::Responder for SocketGetIpMulticastInterfaceResponder {
13415    type ControlHandle = SocketControlHandle;
13416
13417    fn control_handle(&self) -> &SocketControlHandle {
13418        &self.control_handle
13419    }
13420
13421    fn drop_without_shutdown(mut self) {
13422        // Safety: drops once, never accessed again due to mem::forget
13423        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13424        // Prevent Drop from running (which would shut down the channel)
13425        std::mem::forget(self);
13426    }
13427}
13428
13429impl SocketGetIpMulticastInterfaceResponder {
13430    /// Sends a response to the FIDL transaction.
13431    ///
13432    /// Sets the channel to shutdown if an error occurs.
13433    pub fn send(
13434        self,
13435        mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
13436    ) -> Result<(), fidl::Error> {
13437        let _result = self.send_raw(result);
13438        if _result.is_err() {
13439            self.control_handle.shutdown();
13440        }
13441        self.drop_without_shutdown();
13442        _result
13443    }
13444
13445    /// Similar to "send" but does not shutdown the channel if an error occurs.
13446    pub fn send_no_shutdown_on_err(
13447        self,
13448        mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
13449    ) -> Result<(), fidl::Error> {
13450        let _result = self.send_raw(result);
13451        self.drop_without_shutdown();
13452        _result
13453    }
13454
13455    fn send_raw(
13456        &self,
13457        mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
13458    ) -> Result<(), fidl::Error> {
13459        self.control_handle.inner.send::<fidl::encoding::ResultType<
13460            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastInterfaceResponse,
13461            fidl_fuchsia_posix::Errno,
13462        >>(
13463            result.map(|value| (value,)),
13464            self.tx_id,
13465            0x320bd14c4df046c4,
13466            fidl::encoding::DynamicFlags::empty(),
13467        )
13468    }
13469}
13470
13471#[must_use = "FIDL methods require a response to be sent"]
13472#[derive(Debug)]
13473pub struct SocketSetIpMulticastTtlResponder {
13474    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
13475    tx_id: u32,
13476}
13477
13478/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
13479/// if the responder is dropped without sending a response, so that the client
13480/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
13481impl std::ops::Drop for SocketSetIpMulticastTtlResponder {
13482    fn drop(&mut self) {
13483        self.control_handle.shutdown();
13484        // Safety: drops once, never accessed again
13485        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13486    }
13487}
13488
13489impl fidl::endpoints::Responder for SocketSetIpMulticastTtlResponder {
13490    type ControlHandle = SocketControlHandle;
13491
13492    fn control_handle(&self) -> &SocketControlHandle {
13493        &self.control_handle
13494    }
13495
13496    fn drop_without_shutdown(mut self) {
13497        // Safety: drops once, never accessed again due to mem::forget
13498        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13499        // Prevent Drop from running (which would shut down the channel)
13500        std::mem::forget(self);
13501    }
13502}
13503
13504impl SocketSetIpMulticastTtlResponder {
13505    /// Sends a response to the FIDL transaction.
13506    ///
13507    /// Sets the channel to shutdown if an error occurs.
13508    pub fn send(
13509        self,
13510        mut result: Result<(), fidl_fuchsia_posix::Errno>,
13511    ) -> Result<(), fidl::Error> {
13512        let _result = self.send_raw(result);
13513        if _result.is_err() {
13514            self.control_handle.shutdown();
13515        }
13516        self.drop_without_shutdown();
13517        _result
13518    }
13519
13520    /// Similar to "send" but does not shutdown the channel if an error occurs.
13521    pub fn send_no_shutdown_on_err(
13522        self,
13523        mut result: Result<(), fidl_fuchsia_posix::Errno>,
13524    ) -> Result<(), fidl::Error> {
13525        let _result = self.send_raw(result);
13526        self.drop_without_shutdown();
13527        _result
13528    }
13529
13530    fn send_raw(
13531        &self,
13532        mut result: Result<(), fidl_fuchsia_posix::Errno>,
13533    ) -> Result<(), fidl::Error> {
13534        self.control_handle.inner.send::<fidl::encoding::ResultType<
13535            fidl::encoding::EmptyStruct,
13536            fidl_fuchsia_posix::Errno,
13537        >>(
13538            result,
13539            self.tx_id,
13540            0x63134d53772916a1,
13541            fidl::encoding::DynamicFlags::empty(),
13542        )
13543    }
13544}
13545
13546#[must_use = "FIDL methods require a response to be sent"]
13547#[derive(Debug)]
13548pub struct SocketGetIpMulticastTtlResponder {
13549    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
13550    tx_id: u32,
13551}
13552
13553/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
13554/// if the responder is dropped without sending a response, so that the client
13555/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
13556impl std::ops::Drop for SocketGetIpMulticastTtlResponder {
13557    fn drop(&mut self) {
13558        self.control_handle.shutdown();
13559        // Safety: drops once, never accessed again
13560        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13561    }
13562}
13563
13564impl fidl::endpoints::Responder for SocketGetIpMulticastTtlResponder {
13565    type ControlHandle = SocketControlHandle;
13566
13567    fn control_handle(&self) -> &SocketControlHandle {
13568        &self.control_handle
13569    }
13570
13571    fn drop_without_shutdown(mut self) {
13572        // Safety: drops once, never accessed again due to mem::forget
13573        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13574        // Prevent Drop from running (which would shut down the channel)
13575        std::mem::forget(self);
13576    }
13577}
13578
13579impl SocketGetIpMulticastTtlResponder {
13580    /// Sends a response to the FIDL transaction.
13581    ///
13582    /// Sets the channel to shutdown if an error occurs.
13583    pub fn send(
13584        self,
13585        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
13586    ) -> Result<(), fidl::Error> {
13587        let _result = self.send_raw(result);
13588        if _result.is_err() {
13589            self.control_handle.shutdown();
13590        }
13591        self.drop_without_shutdown();
13592        _result
13593    }
13594
13595    /// Similar to "send" but does not shutdown the channel if an error occurs.
13596    pub fn send_no_shutdown_on_err(
13597        self,
13598        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
13599    ) -> Result<(), fidl::Error> {
13600        let _result = self.send_raw(result);
13601        self.drop_without_shutdown();
13602        _result
13603    }
13604
13605    fn send_raw(
13606        &self,
13607        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
13608    ) -> Result<(), fidl::Error> {
13609        self.control_handle.inner.send::<fidl::encoding::ResultType<
13610            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastTtlResponse,
13611            fidl_fuchsia_posix::Errno,
13612        >>(
13613            result.map(|value| (value,)),
13614            self.tx_id,
13615            0x4665cd378f39e1a,
13616            fidl::encoding::DynamicFlags::empty(),
13617        )
13618    }
13619}
13620
13621#[must_use = "FIDL methods require a response to be sent"]
13622#[derive(Debug)]
13623pub struct SocketSetIpMulticastLoopbackResponder {
13624    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
13625    tx_id: u32,
13626}
13627
13628/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
13629/// if the responder is dropped without sending a response, so that the client
13630/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
13631impl std::ops::Drop for SocketSetIpMulticastLoopbackResponder {
13632    fn drop(&mut self) {
13633        self.control_handle.shutdown();
13634        // Safety: drops once, never accessed again
13635        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13636    }
13637}
13638
13639impl fidl::endpoints::Responder for SocketSetIpMulticastLoopbackResponder {
13640    type ControlHandle = SocketControlHandle;
13641
13642    fn control_handle(&self) -> &SocketControlHandle {
13643        &self.control_handle
13644    }
13645
13646    fn drop_without_shutdown(mut self) {
13647        // Safety: drops once, never accessed again due to mem::forget
13648        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13649        // Prevent Drop from running (which would shut down the channel)
13650        std::mem::forget(self);
13651    }
13652}
13653
13654impl SocketSetIpMulticastLoopbackResponder {
13655    /// Sends a response to the FIDL transaction.
13656    ///
13657    /// Sets the channel to shutdown if an error occurs.
13658    pub fn send(
13659        self,
13660        mut result: Result<(), fidl_fuchsia_posix::Errno>,
13661    ) -> Result<(), fidl::Error> {
13662        let _result = self.send_raw(result);
13663        if _result.is_err() {
13664            self.control_handle.shutdown();
13665        }
13666        self.drop_without_shutdown();
13667        _result
13668    }
13669
13670    /// Similar to "send" but does not shutdown the channel if an error occurs.
13671    pub fn send_no_shutdown_on_err(
13672        self,
13673        mut result: Result<(), fidl_fuchsia_posix::Errno>,
13674    ) -> Result<(), fidl::Error> {
13675        let _result = self.send_raw(result);
13676        self.drop_without_shutdown();
13677        _result
13678    }
13679
13680    fn send_raw(
13681        &self,
13682        mut result: Result<(), fidl_fuchsia_posix::Errno>,
13683    ) -> Result<(), fidl::Error> {
13684        self.control_handle.inner.send::<fidl::encoding::ResultType<
13685            fidl::encoding::EmptyStruct,
13686            fidl_fuchsia_posix::Errno,
13687        >>(
13688            result,
13689            self.tx_id,
13690            0x20c55c11f00943ea,
13691            fidl::encoding::DynamicFlags::empty(),
13692        )
13693    }
13694}
13695
13696#[must_use = "FIDL methods require a response to be sent"]
13697#[derive(Debug)]
13698pub struct SocketGetIpMulticastLoopbackResponder {
13699    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
13700    tx_id: u32,
13701}
13702
13703/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
13704/// if the responder is dropped without sending a response, so that the client
13705/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
13706impl std::ops::Drop for SocketGetIpMulticastLoopbackResponder {
13707    fn drop(&mut self) {
13708        self.control_handle.shutdown();
13709        // Safety: drops once, never accessed again
13710        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13711    }
13712}
13713
13714impl fidl::endpoints::Responder for SocketGetIpMulticastLoopbackResponder {
13715    type ControlHandle = SocketControlHandle;
13716
13717    fn control_handle(&self) -> &SocketControlHandle {
13718        &self.control_handle
13719    }
13720
13721    fn drop_without_shutdown(mut self) {
13722        // Safety: drops once, never accessed again due to mem::forget
13723        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13724        // Prevent Drop from running (which would shut down the channel)
13725        std::mem::forget(self);
13726    }
13727}
13728
13729impl SocketGetIpMulticastLoopbackResponder {
13730    /// Sends a response to the FIDL transaction.
13731    ///
13732    /// Sets the channel to shutdown if an error occurs.
13733    pub fn send(
13734        self,
13735        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13736    ) -> Result<(), fidl::Error> {
13737        let _result = self.send_raw(result);
13738        if _result.is_err() {
13739            self.control_handle.shutdown();
13740        }
13741        self.drop_without_shutdown();
13742        _result
13743    }
13744
13745    /// Similar to "send" but does not shutdown the channel if an error occurs.
13746    pub fn send_no_shutdown_on_err(
13747        self,
13748        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13749    ) -> Result<(), fidl::Error> {
13750        let _result = self.send_raw(result);
13751        self.drop_without_shutdown();
13752        _result
13753    }
13754
13755    fn send_raw(
13756        &self,
13757        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13758    ) -> Result<(), fidl::Error> {
13759        self.control_handle.inner.send::<fidl::encoding::ResultType<
13760            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpMulticastLoopbackResponse,
13761            fidl_fuchsia_posix::Errno,
13762        >>(
13763            result.map(|value| (value,)),
13764            self.tx_id,
13765            0x3b6b26ff558298f2,
13766            fidl::encoding::DynamicFlags::empty(),
13767        )
13768    }
13769}
13770
13771#[must_use = "FIDL methods require a response to be sent"]
13772#[derive(Debug)]
13773pub struct SocketAddIpMembershipResponder {
13774    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
13775    tx_id: u32,
13776}
13777
13778/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
13779/// if the responder is dropped without sending a response, so that the client
13780/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
13781impl std::ops::Drop for SocketAddIpMembershipResponder {
13782    fn drop(&mut self) {
13783        self.control_handle.shutdown();
13784        // Safety: drops once, never accessed again
13785        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13786    }
13787}
13788
13789impl fidl::endpoints::Responder for SocketAddIpMembershipResponder {
13790    type ControlHandle = SocketControlHandle;
13791
13792    fn control_handle(&self) -> &SocketControlHandle {
13793        &self.control_handle
13794    }
13795
13796    fn drop_without_shutdown(mut self) {
13797        // Safety: drops once, never accessed again due to mem::forget
13798        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13799        // Prevent Drop from running (which would shut down the channel)
13800        std::mem::forget(self);
13801    }
13802}
13803
13804impl SocketAddIpMembershipResponder {
13805    /// Sends a response to the FIDL transaction.
13806    ///
13807    /// Sets the channel to shutdown if an error occurs.
13808    pub fn send(
13809        self,
13810        mut result: Result<(), fidl_fuchsia_posix::Errno>,
13811    ) -> Result<(), fidl::Error> {
13812        let _result = self.send_raw(result);
13813        if _result.is_err() {
13814            self.control_handle.shutdown();
13815        }
13816        self.drop_without_shutdown();
13817        _result
13818    }
13819
13820    /// Similar to "send" but does not shutdown the channel if an error occurs.
13821    pub fn send_no_shutdown_on_err(
13822        self,
13823        mut result: Result<(), fidl_fuchsia_posix::Errno>,
13824    ) -> Result<(), fidl::Error> {
13825        let _result = self.send_raw(result);
13826        self.drop_without_shutdown();
13827        _result
13828    }
13829
13830    fn send_raw(
13831        &self,
13832        mut result: Result<(), fidl_fuchsia_posix::Errno>,
13833    ) -> Result<(), fidl::Error> {
13834        self.control_handle.inner.send::<fidl::encoding::ResultType<
13835            fidl::encoding::EmptyStruct,
13836            fidl_fuchsia_posix::Errno,
13837        >>(
13838            result,
13839            self.tx_id,
13840            0x76bc7df115a3b4d0,
13841            fidl::encoding::DynamicFlags::empty(),
13842        )
13843    }
13844}
13845
13846#[must_use = "FIDL methods require a response to be sent"]
13847#[derive(Debug)]
13848pub struct SocketDropIpMembershipResponder {
13849    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
13850    tx_id: u32,
13851}
13852
13853/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
13854/// if the responder is dropped without sending a response, so that the client
13855/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
13856impl std::ops::Drop for SocketDropIpMembershipResponder {
13857    fn drop(&mut self) {
13858        self.control_handle.shutdown();
13859        // Safety: drops once, never accessed again
13860        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13861    }
13862}
13863
13864impl fidl::endpoints::Responder for SocketDropIpMembershipResponder {
13865    type ControlHandle = SocketControlHandle;
13866
13867    fn control_handle(&self) -> &SocketControlHandle {
13868        &self.control_handle
13869    }
13870
13871    fn drop_without_shutdown(mut self) {
13872        // Safety: drops once, never accessed again due to mem::forget
13873        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13874        // Prevent Drop from running (which would shut down the channel)
13875        std::mem::forget(self);
13876    }
13877}
13878
13879impl SocketDropIpMembershipResponder {
13880    /// Sends a response to the FIDL transaction.
13881    ///
13882    /// Sets the channel to shutdown if an error occurs.
13883    pub fn send(
13884        self,
13885        mut result: Result<(), fidl_fuchsia_posix::Errno>,
13886    ) -> Result<(), fidl::Error> {
13887        let _result = self.send_raw(result);
13888        if _result.is_err() {
13889            self.control_handle.shutdown();
13890        }
13891        self.drop_without_shutdown();
13892        _result
13893    }
13894
13895    /// Similar to "send" but does not shutdown the channel if an error occurs.
13896    pub fn send_no_shutdown_on_err(
13897        self,
13898        mut result: Result<(), fidl_fuchsia_posix::Errno>,
13899    ) -> Result<(), fidl::Error> {
13900        let _result = self.send_raw(result);
13901        self.drop_without_shutdown();
13902        _result
13903    }
13904
13905    fn send_raw(
13906        &self,
13907        mut result: Result<(), fidl_fuchsia_posix::Errno>,
13908    ) -> Result<(), fidl::Error> {
13909        self.control_handle.inner.send::<fidl::encoding::ResultType<
13910            fidl::encoding::EmptyStruct,
13911            fidl_fuchsia_posix::Errno,
13912        >>(
13913            result,
13914            self.tx_id,
13915            0x2888f3099188d03,
13916            fidl::encoding::DynamicFlags::empty(),
13917        )
13918    }
13919}
13920
13921#[must_use = "FIDL methods require a response to be sent"]
13922#[derive(Debug)]
13923pub struct SocketSetIpTransparentResponder {
13924    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
13925    tx_id: u32,
13926}
13927
13928/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
13929/// if the responder is dropped without sending a response, so that the client
13930/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
13931impl std::ops::Drop for SocketSetIpTransparentResponder {
13932    fn drop(&mut self) {
13933        self.control_handle.shutdown();
13934        // Safety: drops once, never accessed again
13935        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13936    }
13937}
13938
13939impl fidl::endpoints::Responder for SocketSetIpTransparentResponder {
13940    type ControlHandle = SocketControlHandle;
13941
13942    fn control_handle(&self) -> &SocketControlHandle {
13943        &self.control_handle
13944    }
13945
13946    fn drop_without_shutdown(mut self) {
13947        // Safety: drops once, never accessed again due to mem::forget
13948        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13949        // Prevent Drop from running (which would shut down the channel)
13950        std::mem::forget(self);
13951    }
13952}
13953
13954impl SocketSetIpTransparentResponder {
13955    /// Sends a response to the FIDL transaction.
13956    ///
13957    /// Sets the channel to shutdown if an error occurs.
13958    pub fn send(
13959        self,
13960        mut result: Result<(), fidl_fuchsia_posix::Errno>,
13961    ) -> Result<(), fidl::Error> {
13962        let _result = self.send_raw(result);
13963        if _result.is_err() {
13964            self.control_handle.shutdown();
13965        }
13966        self.drop_without_shutdown();
13967        _result
13968    }
13969
13970    /// Similar to "send" but does not shutdown the channel if an error occurs.
13971    pub fn send_no_shutdown_on_err(
13972        self,
13973        mut result: Result<(), fidl_fuchsia_posix::Errno>,
13974    ) -> Result<(), fidl::Error> {
13975        let _result = self.send_raw(result);
13976        self.drop_without_shutdown();
13977        _result
13978    }
13979
13980    fn send_raw(
13981        &self,
13982        mut result: Result<(), fidl_fuchsia_posix::Errno>,
13983    ) -> Result<(), fidl::Error> {
13984        self.control_handle.inner.send::<fidl::encoding::ResultType<
13985            fidl::encoding::EmptyStruct,
13986            fidl_fuchsia_posix::Errno,
13987        >>(
13988            result,
13989            self.tx_id,
13990            0x1ae532b0c066e3a0,
13991            fidl::encoding::DynamicFlags::empty(),
13992        )
13993    }
13994}
13995
13996#[must_use = "FIDL methods require a response to be sent"]
13997#[derive(Debug)]
13998pub struct SocketGetIpTransparentResponder {
13999    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
14000    tx_id: u32,
14001}
14002
14003/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
14004/// if the responder is dropped without sending a response, so that the client
14005/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
14006impl std::ops::Drop for SocketGetIpTransparentResponder {
14007    fn drop(&mut self) {
14008        self.control_handle.shutdown();
14009        // Safety: drops once, never accessed again
14010        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14011    }
14012}
14013
14014impl fidl::endpoints::Responder for SocketGetIpTransparentResponder {
14015    type ControlHandle = SocketControlHandle;
14016
14017    fn control_handle(&self) -> &SocketControlHandle {
14018        &self.control_handle
14019    }
14020
14021    fn drop_without_shutdown(mut self) {
14022        // Safety: drops once, never accessed again due to mem::forget
14023        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14024        // Prevent Drop from running (which would shut down the channel)
14025        std::mem::forget(self);
14026    }
14027}
14028
14029impl SocketGetIpTransparentResponder {
14030    /// Sends a response to the FIDL transaction.
14031    ///
14032    /// Sets the channel to shutdown if an error occurs.
14033    pub fn send(
14034        self,
14035        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
14036    ) -> Result<(), fidl::Error> {
14037        let _result = self.send_raw(result);
14038        if _result.is_err() {
14039            self.control_handle.shutdown();
14040        }
14041        self.drop_without_shutdown();
14042        _result
14043    }
14044
14045    /// Similar to "send" but does not shutdown the channel if an error occurs.
14046    pub fn send_no_shutdown_on_err(
14047        self,
14048        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
14049    ) -> Result<(), fidl::Error> {
14050        let _result = self.send_raw(result);
14051        self.drop_without_shutdown();
14052        _result
14053    }
14054
14055    fn send_raw(
14056        &self,
14057        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
14058    ) -> Result<(), fidl::Error> {
14059        self.control_handle.inner.send::<fidl::encoding::ResultType<
14060            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpTransparentResponse,
14061            fidl_fuchsia_posix::Errno,
14062        >>(
14063            result.map(|value| (value,)),
14064            self.tx_id,
14065            0x51d43695962ebfb5,
14066            fidl::encoding::DynamicFlags::empty(),
14067        )
14068    }
14069}
14070
14071#[must_use = "FIDL methods require a response to be sent"]
14072#[derive(Debug)]
14073pub struct SocketSetIpReceiveOriginalDestinationAddressResponder {
14074    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
14075    tx_id: u32,
14076}
14077
14078/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
14079/// if the responder is dropped without sending a response, so that the client
14080/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
14081impl std::ops::Drop for SocketSetIpReceiveOriginalDestinationAddressResponder {
14082    fn drop(&mut self) {
14083        self.control_handle.shutdown();
14084        // Safety: drops once, never accessed again
14085        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14086    }
14087}
14088
14089impl fidl::endpoints::Responder for SocketSetIpReceiveOriginalDestinationAddressResponder {
14090    type ControlHandle = SocketControlHandle;
14091
14092    fn control_handle(&self) -> &SocketControlHandle {
14093        &self.control_handle
14094    }
14095
14096    fn drop_without_shutdown(mut self) {
14097        // Safety: drops once, never accessed again due to mem::forget
14098        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14099        // Prevent Drop from running (which would shut down the channel)
14100        std::mem::forget(self);
14101    }
14102}
14103
14104impl SocketSetIpReceiveOriginalDestinationAddressResponder {
14105    /// Sends a response to the FIDL transaction.
14106    ///
14107    /// Sets the channel to shutdown if an error occurs.
14108    pub fn send(
14109        self,
14110        mut result: Result<(), fidl_fuchsia_posix::Errno>,
14111    ) -> Result<(), fidl::Error> {
14112        let _result = self.send_raw(result);
14113        if _result.is_err() {
14114            self.control_handle.shutdown();
14115        }
14116        self.drop_without_shutdown();
14117        _result
14118    }
14119
14120    /// Similar to "send" but does not shutdown the channel if an error occurs.
14121    pub fn send_no_shutdown_on_err(
14122        self,
14123        mut result: Result<(), fidl_fuchsia_posix::Errno>,
14124    ) -> Result<(), fidl::Error> {
14125        let _result = self.send_raw(result);
14126        self.drop_without_shutdown();
14127        _result
14128    }
14129
14130    fn send_raw(
14131        &self,
14132        mut result: Result<(), fidl_fuchsia_posix::Errno>,
14133    ) -> Result<(), fidl::Error> {
14134        self.control_handle.inner.send::<fidl::encoding::ResultType<
14135            fidl::encoding::EmptyStruct,
14136            fidl_fuchsia_posix::Errno,
14137        >>(
14138            result,
14139            self.tx_id,
14140            0x4722b4ce52f7840,
14141            fidl::encoding::DynamicFlags::empty(),
14142        )
14143    }
14144}
14145
14146#[must_use = "FIDL methods require a response to be sent"]
14147#[derive(Debug)]
14148pub struct SocketGetIpReceiveOriginalDestinationAddressResponder {
14149    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
14150    tx_id: u32,
14151}
14152
14153/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
14154/// if the responder is dropped without sending a response, so that the client
14155/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
14156impl std::ops::Drop for SocketGetIpReceiveOriginalDestinationAddressResponder {
14157    fn drop(&mut self) {
14158        self.control_handle.shutdown();
14159        // Safety: drops once, never accessed again
14160        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14161    }
14162}
14163
14164impl fidl::endpoints::Responder for SocketGetIpReceiveOriginalDestinationAddressResponder {
14165    type ControlHandle = SocketControlHandle;
14166
14167    fn control_handle(&self) -> &SocketControlHandle {
14168        &self.control_handle
14169    }
14170
14171    fn drop_without_shutdown(mut self) {
14172        // Safety: drops once, never accessed again due to mem::forget
14173        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14174        // Prevent Drop from running (which would shut down the channel)
14175        std::mem::forget(self);
14176    }
14177}
14178
14179impl SocketGetIpReceiveOriginalDestinationAddressResponder {
14180    /// Sends a response to the FIDL transaction.
14181    ///
14182    /// Sets the channel to shutdown if an error occurs.
14183    pub fn send(
14184        self,
14185        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
14186    ) -> Result<(), fidl::Error> {
14187        let _result = self.send_raw(result);
14188        if _result.is_err() {
14189            self.control_handle.shutdown();
14190        }
14191        self.drop_without_shutdown();
14192        _result
14193    }
14194
14195    /// Similar to "send" but does not shutdown the channel if an error occurs.
14196    pub fn send_no_shutdown_on_err(
14197        self,
14198        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
14199    ) -> Result<(), fidl::Error> {
14200        let _result = self.send_raw(result);
14201        self.drop_without_shutdown();
14202        _result
14203    }
14204
14205    fn send_raw(
14206        &self,
14207        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
14208    ) -> Result<(), fidl::Error> {
14209        self.control_handle.inner.send::<fidl::encoding::ResultType<fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse, fidl_fuchsia_posix::Errno>>(
14210            result.map(|value| (value,)),
14211            self.tx_id,
14212            0x2a0e7dc5d6bfdfe9,
14213            fidl::encoding::DynamicFlags::empty()
14214        )
14215    }
14216}
14217
14218#[must_use = "FIDL methods require a response to be sent"]
14219#[derive(Debug)]
14220pub struct SocketAddIpv6MembershipResponder {
14221    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
14222    tx_id: u32,
14223}
14224
14225/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
14226/// if the responder is dropped without sending a response, so that the client
14227/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
14228impl std::ops::Drop for SocketAddIpv6MembershipResponder {
14229    fn drop(&mut self) {
14230        self.control_handle.shutdown();
14231        // Safety: drops once, never accessed again
14232        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14233    }
14234}
14235
14236impl fidl::endpoints::Responder for SocketAddIpv6MembershipResponder {
14237    type ControlHandle = SocketControlHandle;
14238
14239    fn control_handle(&self) -> &SocketControlHandle {
14240        &self.control_handle
14241    }
14242
14243    fn drop_without_shutdown(mut self) {
14244        // Safety: drops once, never accessed again due to mem::forget
14245        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14246        // Prevent Drop from running (which would shut down the channel)
14247        std::mem::forget(self);
14248    }
14249}
14250
14251impl SocketAddIpv6MembershipResponder {
14252    /// Sends a response to the FIDL transaction.
14253    ///
14254    /// Sets the channel to shutdown if an error occurs.
14255    pub fn send(
14256        self,
14257        mut result: Result<(), fidl_fuchsia_posix::Errno>,
14258    ) -> Result<(), fidl::Error> {
14259        let _result = self.send_raw(result);
14260        if _result.is_err() {
14261            self.control_handle.shutdown();
14262        }
14263        self.drop_without_shutdown();
14264        _result
14265    }
14266
14267    /// Similar to "send" but does not shutdown the channel if an error occurs.
14268    pub fn send_no_shutdown_on_err(
14269        self,
14270        mut result: Result<(), fidl_fuchsia_posix::Errno>,
14271    ) -> Result<(), fidl::Error> {
14272        let _result = self.send_raw(result);
14273        self.drop_without_shutdown();
14274        _result
14275    }
14276
14277    fn send_raw(
14278        &self,
14279        mut result: Result<(), fidl_fuchsia_posix::Errno>,
14280    ) -> Result<(), fidl::Error> {
14281        self.control_handle.inner.send::<fidl::encoding::ResultType<
14282            fidl::encoding::EmptyStruct,
14283            fidl_fuchsia_posix::Errno,
14284        >>(
14285            result,
14286            self.tx_id,
14287            0x7c94727acb4ea4b3,
14288            fidl::encoding::DynamicFlags::empty(),
14289        )
14290    }
14291}
14292
14293#[must_use = "FIDL methods require a response to be sent"]
14294#[derive(Debug)]
14295pub struct SocketDropIpv6MembershipResponder {
14296    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
14297    tx_id: u32,
14298}
14299
14300/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
14301/// if the responder is dropped without sending a response, so that the client
14302/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
14303impl std::ops::Drop for SocketDropIpv6MembershipResponder {
14304    fn drop(&mut self) {
14305        self.control_handle.shutdown();
14306        // Safety: drops once, never accessed again
14307        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14308    }
14309}
14310
14311impl fidl::endpoints::Responder for SocketDropIpv6MembershipResponder {
14312    type ControlHandle = SocketControlHandle;
14313
14314    fn control_handle(&self) -> &SocketControlHandle {
14315        &self.control_handle
14316    }
14317
14318    fn drop_without_shutdown(mut self) {
14319        // Safety: drops once, never accessed again due to mem::forget
14320        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14321        // Prevent Drop from running (which would shut down the channel)
14322        std::mem::forget(self);
14323    }
14324}
14325
14326impl SocketDropIpv6MembershipResponder {
14327    /// Sends a response to the FIDL transaction.
14328    ///
14329    /// Sets the channel to shutdown if an error occurs.
14330    pub fn send(
14331        self,
14332        mut result: Result<(), fidl_fuchsia_posix::Errno>,
14333    ) -> Result<(), fidl::Error> {
14334        let _result = self.send_raw(result);
14335        if _result.is_err() {
14336            self.control_handle.shutdown();
14337        }
14338        self.drop_without_shutdown();
14339        _result
14340    }
14341
14342    /// Similar to "send" but does not shutdown the channel if an error occurs.
14343    pub fn send_no_shutdown_on_err(
14344        self,
14345        mut result: Result<(), fidl_fuchsia_posix::Errno>,
14346    ) -> Result<(), fidl::Error> {
14347        let _result = self.send_raw(result);
14348        self.drop_without_shutdown();
14349        _result
14350    }
14351
14352    fn send_raw(
14353        &self,
14354        mut result: Result<(), fidl_fuchsia_posix::Errno>,
14355    ) -> Result<(), fidl::Error> {
14356        self.control_handle.inner.send::<fidl::encoding::ResultType<
14357            fidl::encoding::EmptyStruct,
14358            fidl_fuchsia_posix::Errno,
14359        >>(
14360            result,
14361            self.tx_id,
14362            0x42104c70ccaba304,
14363            fidl::encoding::DynamicFlags::empty(),
14364        )
14365    }
14366}
14367
14368#[must_use = "FIDL methods require a response to be sent"]
14369#[derive(Debug)]
14370pub struct SocketSetIpv6MulticastInterfaceResponder {
14371    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
14372    tx_id: u32,
14373}
14374
14375/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
14376/// if the responder is dropped without sending a response, so that the client
14377/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
14378impl std::ops::Drop for SocketSetIpv6MulticastInterfaceResponder {
14379    fn drop(&mut self) {
14380        self.control_handle.shutdown();
14381        // Safety: drops once, never accessed again
14382        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14383    }
14384}
14385
14386impl fidl::endpoints::Responder for SocketSetIpv6MulticastInterfaceResponder {
14387    type ControlHandle = SocketControlHandle;
14388
14389    fn control_handle(&self) -> &SocketControlHandle {
14390        &self.control_handle
14391    }
14392
14393    fn drop_without_shutdown(mut self) {
14394        // Safety: drops once, never accessed again due to mem::forget
14395        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14396        // Prevent Drop from running (which would shut down the channel)
14397        std::mem::forget(self);
14398    }
14399}
14400
14401impl SocketSetIpv6MulticastInterfaceResponder {
14402    /// Sends a response to the FIDL transaction.
14403    ///
14404    /// Sets the channel to shutdown if an error occurs.
14405    pub fn send(
14406        self,
14407        mut result: Result<(), fidl_fuchsia_posix::Errno>,
14408    ) -> Result<(), fidl::Error> {
14409        let _result = self.send_raw(result);
14410        if _result.is_err() {
14411            self.control_handle.shutdown();
14412        }
14413        self.drop_without_shutdown();
14414        _result
14415    }
14416
14417    /// Similar to "send" but does not shutdown the channel if an error occurs.
14418    pub fn send_no_shutdown_on_err(
14419        self,
14420        mut result: Result<(), fidl_fuchsia_posix::Errno>,
14421    ) -> Result<(), fidl::Error> {
14422        let _result = self.send_raw(result);
14423        self.drop_without_shutdown();
14424        _result
14425    }
14426
14427    fn send_raw(
14428        &self,
14429        mut result: Result<(), fidl_fuchsia_posix::Errno>,
14430    ) -> Result<(), fidl::Error> {
14431        self.control_handle.inner.send::<fidl::encoding::ResultType<
14432            fidl::encoding::EmptyStruct,
14433            fidl_fuchsia_posix::Errno,
14434        >>(
14435            result,
14436            self.tx_id,
14437            0x135f76db3774ab3b,
14438            fidl::encoding::DynamicFlags::empty(),
14439        )
14440    }
14441}
14442
14443#[must_use = "FIDL methods require a response to be sent"]
14444#[derive(Debug)]
14445pub struct SocketGetIpv6MulticastInterfaceResponder {
14446    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
14447    tx_id: u32,
14448}
14449
14450/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
14451/// if the responder is dropped without sending a response, so that the client
14452/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
14453impl std::ops::Drop for SocketGetIpv6MulticastInterfaceResponder {
14454    fn drop(&mut self) {
14455        self.control_handle.shutdown();
14456        // Safety: drops once, never accessed again
14457        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14458    }
14459}
14460
14461impl fidl::endpoints::Responder for SocketGetIpv6MulticastInterfaceResponder {
14462    type ControlHandle = SocketControlHandle;
14463
14464    fn control_handle(&self) -> &SocketControlHandle {
14465        &self.control_handle
14466    }
14467
14468    fn drop_without_shutdown(mut self) {
14469        // Safety: drops once, never accessed again due to mem::forget
14470        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14471        // Prevent Drop from running (which would shut down the channel)
14472        std::mem::forget(self);
14473    }
14474}
14475
14476impl SocketGetIpv6MulticastInterfaceResponder {
14477    /// Sends a response to the FIDL transaction.
14478    ///
14479    /// Sets the channel to shutdown if an error occurs.
14480    pub fn send(
14481        self,
14482        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
14483    ) -> Result<(), fidl::Error> {
14484        let _result = self.send_raw(result);
14485        if _result.is_err() {
14486            self.control_handle.shutdown();
14487        }
14488        self.drop_without_shutdown();
14489        _result
14490    }
14491
14492    /// Similar to "send" but does not shutdown the channel if an error occurs.
14493    pub fn send_no_shutdown_on_err(
14494        self,
14495        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
14496    ) -> Result<(), fidl::Error> {
14497        let _result = self.send_raw(result);
14498        self.drop_without_shutdown();
14499        _result
14500    }
14501
14502    fn send_raw(
14503        &self,
14504        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
14505    ) -> Result<(), fidl::Error> {
14506        self.control_handle.inner.send::<fidl::encoding::ResultType<
14507            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
14508            fidl_fuchsia_posix::Errno,
14509        >>(
14510            result.map(|value| (value,)),
14511            self.tx_id,
14512            0x1f26fcdd348f1882,
14513            fidl::encoding::DynamicFlags::empty(),
14514        )
14515    }
14516}
14517
14518#[must_use = "FIDL methods require a response to be sent"]
14519#[derive(Debug)]
14520pub struct SocketSetIpv6UnicastHopsResponder {
14521    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
14522    tx_id: u32,
14523}
14524
14525/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
14526/// if the responder is dropped without sending a response, so that the client
14527/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
14528impl std::ops::Drop for SocketSetIpv6UnicastHopsResponder {
14529    fn drop(&mut self) {
14530        self.control_handle.shutdown();
14531        // Safety: drops once, never accessed again
14532        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14533    }
14534}
14535
14536impl fidl::endpoints::Responder for SocketSetIpv6UnicastHopsResponder {
14537    type ControlHandle = SocketControlHandle;
14538
14539    fn control_handle(&self) -> &SocketControlHandle {
14540        &self.control_handle
14541    }
14542
14543    fn drop_without_shutdown(mut self) {
14544        // Safety: drops once, never accessed again due to mem::forget
14545        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14546        // Prevent Drop from running (which would shut down the channel)
14547        std::mem::forget(self);
14548    }
14549}
14550
14551impl SocketSetIpv6UnicastHopsResponder {
14552    /// Sends a response to the FIDL transaction.
14553    ///
14554    /// Sets the channel to shutdown if an error occurs.
14555    pub fn send(
14556        self,
14557        mut result: Result<(), fidl_fuchsia_posix::Errno>,
14558    ) -> Result<(), fidl::Error> {
14559        let _result = self.send_raw(result);
14560        if _result.is_err() {
14561            self.control_handle.shutdown();
14562        }
14563        self.drop_without_shutdown();
14564        _result
14565    }
14566
14567    /// Similar to "send" but does not shutdown the channel if an error occurs.
14568    pub fn send_no_shutdown_on_err(
14569        self,
14570        mut result: Result<(), fidl_fuchsia_posix::Errno>,
14571    ) -> Result<(), fidl::Error> {
14572        let _result = self.send_raw(result);
14573        self.drop_without_shutdown();
14574        _result
14575    }
14576
14577    fn send_raw(
14578        &self,
14579        mut result: Result<(), fidl_fuchsia_posix::Errno>,
14580    ) -> Result<(), fidl::Error> {
14581        self.control_handle.inner.send::<fidl::encoding::ResultType<
14582            fidl::encoding::EmptyStruct,
14583            fidl_fuchsia_posix::Errno,
14584        >>(
14585            result,
14586            self.tx_id,
14587            0x157d51e98f462859,
14588            fidl::encoding::DynamicFlags::empty(),
14589        )
14590    }
14591}
14592
14593#[must_use = "FIDL methods require a response to be sent"]
14594#[derive(Debug)]
14595pub struct SocketGetIpv6UnicastHopsResponder {
14596    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
14597    tx_id: u32,
14598}
14599
14600/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
14601/// if the responder is dropped without sending a response, so that the client
14602/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
14603impl std::ops::Drop for SocketGetIpv6UnicastHopsResponder {
14604    fn drop(&mut self) {
14605        self.control_handle.shutdown();
14606        // Safety: drops once, never accessed again
14607        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14608    }
14609}
14610
14611impl fidl::endpoints::Responder for SocketGetIpv6UnicastHopsResponder {
14612    type ControlHandle = SocketControlHandle;
14613
14614    fn control_handle(&self) -> &SocketControlHandle {
14615        &self.control_handle
14616    }
14617
14618    fn drop_without_shutdown(mut self) {
14619        // Safety: drops once, never accessed again due to mem::forget
14620        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14621        // Prevent Drop from running (which would shut down the channel)
14622        std::mem::forget(self);
14623    }
14624}
14625
14626impl SocketGetIpv6UnicastHopsResponder {
14627    /// Sends a response to the FIDL transaction.
14628    ///
14629    /// Sets the channel to shutdown if an error occurs.
14630    pub fn send(
14631        self,
14632        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
14633    ) -> Result<(), fidl::Error> {
14634        let _result = self.send_raw(result);
14635        if _result.is_err() {
14636            self.control_handle.shutdown();
14637        }
14638        self.drop_without_shutdown();
14639        _result
14640    }
14641
14642    /// Similar to "send" but does not shutdown the channel if an error occurs.
14643    pub fn send_no_shutdown_on_err(
14644        self,
14645        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
14646    ) -> Result<(), fidl::Error> {
14647        let _result = self.send_raw(result);
14648        self.drop_without_shutdown();
14649        _result
14650    }
14651
14652    fn send_raw(
14653        &self,
14654        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
14655    ) -> Result<(), fidl::Error> {
14656        self.control_handle.inner.send::<fidl::encoding::ResultType<
14657            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6UnicastHopsResponse,
14658            fidl_fuchsia_posix::Errno,
14659        >>(
14660            result.map(|value| (value,)),
14661            self.tx_id,
14662            0x21f4641cad8bd8d2,
14663            fidl::encoding::DynamicFlags::empty(),
14664        )
14665    }
14666}
14667
14668#[must_use = "FIDL methods require a response to be sent"]
14669#[derive(Debug)]
14670pub struct SocketSetIpv6ReceiveHopLimitResponder {
14671    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
14672    tx_id: u32,
14673}
14674
14675/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
14676/// if the responder is dropped without sending a response, so that the client
14677/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
14678impl std::ops::Drop for SocketSetIpv6ReceiveHopLimitResponder {
14679    fn drop(&mut self) {
14680        self.control_handle.shutdown();
14681        // Safety: drops once, never accessed again
14682        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14683    }
14684}
14685
14686impl fidl::endpoints::Responder for SocketSetIpv6ReceiveHopLimitResponder {
14687    type ControlHandle = SocketControlHandle;
14688
14689    fn control_handle(&self) -> &SocketControlHandle {
14690        &self.control_handle
14691    }
14692
14693    fn drop_without_shutdown(mut self) {
14694        // Safety: drops once, never accessed again due to mem::forget
14695        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14696        // Prevent Drop from running (which would shut down the channel)
14697        std::mem::forget(self);
14698    }
14699}
14700
14701impl SocketSetIpv6ReceiveHopLimitResponder {
14702    /// Sends a response to the FIDL transaction.
14703    ///
14704    /// Sets the channel to shutdown if an error occurs.
14705    pub fn send(
14706        self,
14707        mut result: Result<(), fidl_fuchsia_posix::Errno>,
14708    ) -> Result<(), fidl::Error> {
14709        let _result = self.send_raw(result);
14710        if _result.is_err() {
14711            self.control_handle.shutdown();
14712        }
14713        self.drop_without_shutdown();
14714        _result
14715    }
14716
14717    /// Similar to "send" but does not shutdown the channel if an error occurs.
14718    pub fn send_no_shutdown_on_err(
14719        self,
14720        mut result: Result<(), fidl_fuchsia_posix::Errno>,
14721    ) -> Result<(), fidl::Error> {
14722        let _result = self.send_raw(result);
14723        self.drop_without_shutdown();
14724        _result
14725    }
14726
14727    fn send_raw(
14728        &self,
14729        mut result: Result<(), fidl_fuchsia_posix::Errno>,
14730    ) -> Result<(), fidl::Error> {
14731        self.control_handle.inner.send::<fidl::encoding::ResultType<
14732            fidl::encoding::EmptyStruct,
14733            fidl_fuchsia_posix::Errno,
14734        >>(
14735            result,
14736            self.tx_id,
14737            0x5c24808ed2e84a1e,
14738            fidl::encoding::DynamicFlags::empty(),
14739        )
14740    }
14741}
14742
14743#[must_use = "FIDL methods require a response to be sent"]
14744#[derive(Debug)]
14745pub struct SocketGetIpv6ReceiveHopLimitResponder {
14746    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
14747    tx_id: u32,
14748}
14749
14750/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
14751/// if the responder is dropped without sending a response, so that the client
14752/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
14753impl std::ops::Drop for SocketGetIpv6ReceiveHopLimitResponder {
14754    fn drop(&mut self) {
14755        self.control_handle.shutdown();
14756        // Safety: drops once, never accessed again
14757        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14758    }
14759}
14760
14761impl fidl::endpoints::Responder for SocketGetIpv6ReceiveHopLimitResponder {
14762    type ControlHandle = SocketControlHandle;
14763
14764    fn control_handle(&self) -> &SocketControlHandle {
14765        &self.control_handle
14766    }
14767
14768    fn drop_without_shutdown(mut self) {
14769        // Safety: drops once, never accessed again due to mem::forget
14770        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14771        // Prevent Drop from running (which would shut down the channel)
14772        std::mem::forget(self);
14773    }
14774}
14775
14776impl SocketGetIpv6ReceiveHopLimitResponder {
14777    /// Sends a response to the FIDL transaction.
14778    ///
14779    /// Sets the channel to shutdown if an error occurs.
14780    pub fn send(
14781        self,
14782        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
14783    ) -> Result<(), fidl::Error> {
14784        let _result = self.send_raw(result);
14785        if _result.is_err() {
14786            self.control_handle.shutdown();
14787        }
14788        self.drop_without_shutdown();
14789        _result
14790    }
14791
14792    /// Similar to "send" but does not shutdown the channel if an error occurs.
14793    pub fn send_no_shutdown_on_err(
14794        self,
14795        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
14796    ) -> Result<(), fidl::Error> {
14797        let _result = self.send_raw(result);
14798        self.drop_without_shutdown();
14799        _result
14800    }
14801
14802    fn send_raw(
14803        &self,
14804        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
14805    ) -> Result<(), fidl::Error> {
14806        self.control_handle.inner.send::<fidl::encoding::ResultType<
14807            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
14808            fidl_fuchsia_posix::Errno,
14809        >>(
14810            result.map(|value| (value,)),
14811            self.tx_id,
14812            0x341e06689885b4c0,
14813            fidl::encoding::DynamicFlags::empty(),
14814        )
14815    }
14816}
14817
14818#[must_use = "FIDL methods require a response to be sent"]
14819#[derive(Debug)]
14820pub struct SocketSetIpv6MulticastHopsResponder {
14821    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
14822    tx_id: u32,
14823}
14824
14825/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
14826/// if the responder is dropped without sending a response, so that the client
14827/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
14828impl std::ops::Drop for SocketSetIpv6MulticastHopsResponder {
14829    fn drop(&mut self) {
14830        self.control_handle.shutdown();
14831        // Safety: drops once, never accessed again
14832        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14833    }
14834}
14835
14836impl fidl::endpoints::Responder for SocketSetIpv6MulticastHopsResponder {
14837    type ControlHandle = SocketControlHandle;
14838
14839    fn control_handle(&self) -> &SocketControlHandle {
14840        &self.control_handle
14841    }
14842
14843    fn drop_without_shutdown(mut self) {
14844        // Safety: drops once, never accessed again due to mem::forget
14845        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14846        // Prevent Drop from running (which would shut down the channel)
14847        std::mem::forget(self);
14848    }
14849}
14850
14851impl SocketSetIpv6MulticastHopsResponder {
14852    /// Sends a response to the FIDL transaction.
14853    ///
14854    /// Sets the channel to shutdown if an error occurs.
14855    pub fn send(
14856        self,
14857        mut result: Result<(), fidl_fuchsia_posix::Errno>,
14858    ) -> Result<(), fidl::Error> {
14859        let _result = self.send_raw(result);
14860        if _result.is_err() {
14861            self.control_handle.shutdown();
14862        }
14863        self.drop_without_shutdown();
14864        _result
14865    }
14866
14867    /// Similar to "send" but does not shutdown the channel if an error occurs.
14868    pub fn send_no_shutdown_on_err(
14869        self,
14870        mut result: Result<(), fidl_fuchsia_posix::Errno>,
14871    ) -> Result<(), fidl::Error> {
14872        let _result = self.send_raw(result);
14873        self.drop_without_shutdown();
14874        _result
14875    }
14876
14877    fn send_raw(
14878        &self,
14879        mut result: Result<(), fidl_fuchsia_posix::Errno>,
14880    ) -> Result<(), fidl::Error> {
14881        self.control_handle.inner.send::<fidl::encoding::ResultType<
14882            fidl::encoding::EmptyStruct,
14883            fidl_fuchsia_posix::Errno,
14884        >>(
14885            result,
14886            self.tx_id,
14887            0x25b9cd4d181f82c1,
14888            fidl::encoding::DynamicFlags::empty(),
14889        )
14890    }
14891}
14892
14893#[must_use = "FIDL methods require a response to be sent"]
14894#[derive(Debug)]
14895pub struct SocketGetIpv6MulticastHopsResponder {
14896    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
14897    tx_id: u32,
14898}
14899
14900/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
14901/// if the responder is dropped without sending a response, so that the client
14902/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
14903impl std::ops::Drop for SocketGetIpv6MulticastHopsResponder {
14904    fn drop(&mut self) {
14905        self.control_handle.shutdown();
14906        // Safety: drops once, never accessed again
14907        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14908    }
14909}
14910
14911impl fidl::endpoints::Responder for SocketGetIpv6MulticastHopsResponder {
14912    type ControlHandle = SocketControlHandle;
14913
14914    fn control_handle(&self) -> &SocketControlHandle {
14915        &self.control_handle
14916    }
14917
14918    fn drop_without_shutdown(mut self) {
14919        // Safety: drops once, never accessed again due to mem::forget
14920        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14921        // Prevent Drop from running (which would shut down the channel)
14922        std::mem::forget(self);
14923    }
14924}
14925
14926impl SocketGetIpv6MulticastHopsResponder {
14927    /// Sends a response to the FIDL transaction.
14928    ///
14929    /// Sets the channel to shutdown if an error occurs.
14930    pub fn send(
14931        self,
14932        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
14933    ) -> Result<(), fidl::Error> {
14934        let _result = self.send_raw(result);
14935        if _result.is_err() {
14936            self.control_handle.shutdown();
14937        }
14938        self.drop_without_shutdown();
14939        _result
14940    }
14941
14942    /// Similar to "send" but does not shutdown the channel if an error occurs.
14943    pub fn send_no_shutdown_on_err(
14944        self,
14945        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
14946    ) -> Result<(), fidl::Error> {
14947        let _result = self.send_raw(result);
14948        self.drop_without_shutdown();
14949        _result
14950    }
14951
14952    fn send_raw(
14953        &self,
14954        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
14955    ) -> Result<(), fidl::Error> {
14956        self.control_handle.inner.send::<fidl::encoding::ResultType<
14957            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastHopsResponse,
14958            fidl_fuchsia_posix::Errno,
14959        >>(
14960            result.map(|value| (value,)),
14961            self.tx_id,
14962            0x52916948a365012a,
14963            fidl::encoding::DynamicFlags::empty(),
14964        )
14965    }
14966}
14967
14968#[must_use = "FIDL methods require a response to be sent"]
14969#[derive(Debug)]
14970pub struct SocketSetIpv6MulticastLoopbackResponder {
14971    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
14972    tx_id: u32,
14973}
14974
14975/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
14976/// if the responder is dropped without sending a response, so that the client
14977/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
14978impl std::ops::Drop for SocketSetIpv6MulticastLoopbackResponder {
14979    fn drop(&mut self) {
14980        self.control_handle.shutdown();
14981        // Safety: drops once, never accessed again
14982        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14983    }
14984}
14985
14986impl fidl::endpoints::Responder for SocketSetIpv6MulticastLoopbackResponder {
14987    type ControlHandle = SocketControlHandle;
14988
14989    fn control_handle(&self) -> &SocketControlHandle {
14990        &self.control_handle
14991    }
14992
14993    fn drop_without_shutdown(mut self) {
14994        // Safety: drops once, never accessed again due to mem::forget
14995        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
14996        // Prevent Drop from running (which would shut down the channel)
14997        std::mem::forget(self);
14998    }
14999}
15000
15001impl SocketSetIpv6MulticastLoopbackResponder {
15002    /// Sends a response to the FIDL transaction.
15003    ///
15004    /// Sets the channel to shutdown if an error occurs.
15005    pub fn send(
15006        self,
15007        mut result: Result<(), fidl_fuchsia_posix::Errno>,
15008    ) -> Result<(), fidl::Error> {
15009        let _result = self.send_raw(result);
15010        if _result.is_err() {
15011            self.control_handle.shutdown();
15012        }
15013        self.drop_without_shutdown();
15014        _result
15015    }
15016
15017    /// Similar to "send" but does not shutdown the channel if an error occurs.
15018    pub fn send_no_shutdown_on_err(
15019        self,
15020        mut result: Result<(), fidl_fuchsia_posix::Errno>,
15021    ) -> Result<(), fidl::Error> {
15022        let _result = self.send_raw(result);
15023        self.drop_without_shutdown();
15024        _result
15025    }
15026
15027    fn send_raw(
15028        &self,
15029        mut result: Result<(), fidl_fuchsia_posix::Errno>,
15030    ) -> Result<(), fidl::Error> {
15031        self.control_handle.inner.send::<fidl::encoding::ResultType<
15032            fidl::encoding::EmptyStruct,
15033            fidl_fuchsia_posix::Errno,
15034        >>(
15035            result,
15036            self.tx_id,
15037            0x55701c409ff41b40,
15038            fidl::encoding::DynamicFlags::empty(),
15039        )
15040    }
15041}
15042
15043#[must_use = "FIDL methods require a response to be sent"]
15044#[derive(Debug)]
15045pub struct SocketGetIpv6MulticastLoopbackResponder {
15046    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
15047    tx_id: u32,
15048}
15049
15050/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
15051/// if the responder is dropped without sending a response, so that the client
15052/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
15053impl std::ops::Drop for SocketGetIpv6MulticastLoopbackResponder {
15054    fn drop(&mut self) {
15055        self.control_handle.shutdown();
15056        // Safety: drops once, never accessed again
15057        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15058    }
15059}
15060
15061impl fidl::endpoints::Responder for SocketGetIpv6MulticastLoopbackResponder {
15062    type ControlHandle = SocketControlHandle;
15063
15064    fn control_handle(&self) -> &SocketControlHandle {
15065        &self.control_handle
15066    }
15067
15068    fn drop_without_shutdown(mut self) {
15069        // Safety: drops once, never accessed again due to mem::forget
15070        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15071        // Prevent Drop from running (which would shut down the channel)
15072        std::mem::forget(self);
15073    }
15074}
15075
15076impl SocketGetIpv6MulticastLoopbackResponder {
15077    /// Sends a response to the FIDL transaction.
15078    ///
15079    /// Sets the channel to shutdown if an error occurs.
15080    pub fn send(
15081        self,
15082        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
15083    ) -> Result<(), fidl::Error> {
15084        let _result = self.send_raw(result);
15085        if _result.is_err() {
15086            self.control_handle.shutdown();
15087        }
15088        self.drop_without_shutdown();
15089        _result
15090    }
15091
15092    /// Similar to "send" but does not shutdown the channel if an error occurs.
15093    pub fn send_no_shutdown_on_err(
15094        self,
15095        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
15096    ) -> Result<(), fidl::Error> {
15097        let _result = self.send_raw(result);
15098        self.drop_without_shutdown();
15099        _result
15100    }
15101
15102    fn send_raw(
15103        &self,
15104        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
15105    ) -> Result<(), fidl::Error> {
15106        self.control_handle.inner.send::<fidl::encoding::ResultType<
15107            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
15108            fidl_fuchsia_posix::Errno,
15109        >>(
15110            result.map(|value| (value,)),
15111            self.tx_id,
15112            0x4415b701fde319c3,
15113            fidl::encoding::DynamicFlags::empty(),
15114        )
15115    }
15116}
15117
15118#[must_use = "FIDL methods require a response to be sent"]
15119#[derive(Debug)]
15120pub struct SocketSetIpv6OnlyResponder {
15121    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
15122    tx_id: u32,
15123}
15124
15125/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
15126/// if the responder is dropped without sending a response, so that the client
15127/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
15128impl std::ops::Drop for SocketSetIpv6OnlyResponder {
15129    fn drop(&mut self) {
15130        self.control_handle.shutdown();
15131        // Safety: drops once, never accessed again
15132        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15133    }
15134}
15135
15136impl fidl::endpoints::Responder for SocketSetIpv6OnlyResponder {
15137    type ControlHandle = SocketControlHandle;
15138
15139    fn control_handle(&self) -> &SocketControlHandle {
15140        &self.control_handle
15141    }
15142
15143    fn drop_without_shutdown(mut self) {
15144        // Safety: drops once, never accessed again due to mem::forget
15145        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15146        // Prevent Drop from running (which would shut down the channel)
15147        std::mem::forget(self);
15148    }
15149}
15150
15151impl SocketSetIpv6OnlyResponder {
15152    /// Sends a response to the FIDL transaction.
15153    ///
15154    /// Sets the channel to shutdown if an error occurs.
15155    pub fn send(
15156        self,
15157        mut result: Result<(), fidl_fuchsia_posix::Errno>,
15158    ) -> Result<(), fidl::Error> {
15159        let _result = self.send_raw(result);
15160        if _result.is_err() {
15161            self.control_handle.shutdown();
15162        }
15163        self.drop_without_shutdown();
15164        _result
15165    }
15166
15167    /// Similar to "send" but does not shutdown the channel if an error occurs.
15168    pub fn send_no_shutdown_on_err(
15169        self,
15170        mut result: Result<(), fidl_fuchsia_posix::Errno>,
15171    ) -> Result<(), fidl::Error> {
15172        let _result = self.send_raw(result);
15173        self.drop_without_shutdown();
15174        _result
15175    }
15176
15177    fn send_raw(
15178        &self,
15179        mut result: Result<(), fidl_fuchsia_posix::Errno>,
15180    ) -> Result<(), fidl::Error> {
15181        self.control_handle.inner.send::<fidl::encoding::ResultType<
15182            fidl::encoding::EmptyStruct,
15183            fidl_fuchsia_posix::Errno,
15184        >>(
15185            result,
15186            self.tx_id,
15187            0x4873f1364758cbba,
15188            fidl::encoding::DynamicFlags::empty(),
15189        )
15190    }
15191}
15192
15193#[must_use = "FIDL methods require a response to be sent"]
15194#[derive(Debug)]
15195pub struct SocketGetIpv6OnlyResponder {
15196    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
15197    tx_id: u32,
15198}
15199
15200/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
15201/// if the responder is dropped without sending a response, so that the client
15202/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
15203impl std::ops::Drop for SocketGetIpv6OnlyResponder {
15204    fn drop(&mut self) {
15205        self.control_handle.shutdown();
15206        // Safety: drops once, never accessed again
15207        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15208    }
15209}
15210
15211impl fidl::endpoints::Responder for SocketGetIpv6OnlyResponder {
15212    type ControlHandle = SocketControlHandle;
15213
15214    fn control_handle(&self) -> &SocketControlHandle {
15215        &self.control_handle
15216    }
15217
15218    fn drop_without_shutdown(mut self) {
15219        // Safety: drops once, never accessed again due to mem::forget
15220        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15221        // Prevent Drop from running (which would shut down the channel)
15222        std::mem::forget(self);
15223    }
15224}
15225
15226impl SocketGetIpv6OnlyResponder {
15227    /// Sends a response to the FIDL transaction.
15228    ///
15229    /// Sets the channel to shutdown if an error occurs.
15230    pub fn send(
15231        self,
15232        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
15233    ) -> Result<(), fidl::Error> {
15234        let _result = self.send_raw(result);
15235        if _result.is_err() {
15236            self.control_handle.shutdown();
15237        }
15238        self.drop_without_shutdown();
15239        _result
15240    }
15241
15242    /// Similar to "send" but does not shutdown the channel if an error occurs.
15243    pub fn send_no_shutdown_on_err(
15244        self,
15245        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
15246    ) -> Result<(), fidl::Error> {
15247        let _result = self.send_raw(result);
15248        self.drop_without_shutdown();
15249        _result
15250    }
15251
15252    fn send_raw(
15253        &self,
15254        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
15255    ) -> Result<(), fidl::Error> {
15256        self.control_handle.inner.send::<fidl::encoding::ResultType<
15257            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6OnlyResponse,
15258            fidl_fuchsia_posix::Errno,
15259        >>(
15260            result.map(|value| (value,)),
15261            self.tx_id,
15262            0x4aa3340a1a26b89c,
15263            fidl::encoding::DynamicFlags::empty(),
15264        )
15265    }
15266}
15267
15268#[must_use = "FIDL methods require a response to be sent"]
15269#[derive(Debug)]
15270pub struct SocketSetIpv6ReceiveTrafficClassResponder {
15271    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
15272    tx_id: u32,
15273}
15274
15275/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
15276/// if the responder is dropped without sending a response, so that the client
15277/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
15278impl std::ops::Drop for SocketSetIpv6ReceiveTrafficClassResponder {
15279    fn drop(&mut self) {
15280        self.control_handle.shutdown();
15281        // Safety: drops once, never accessed again
15282        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15283    }
15284}
15285
15286impl fidl::endpoints::Responder for SocketSetIpv6ReceiveTrafficClassResponder {
15287    type ControlHandle = SocketControlHandle;
15288
15289    fn control_handle(&self) -> &SocketControlHandle {
15290        &self.control_handle
15291    }
15292
15293    fn drop_without_shutdown(mut self) {
15294        // Safety: drops once, never accessed again due to mem::forget
15295        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15296        // Prevent Drop from running (which would shut down the channel)
15297        std::mem::forget(self);
15298    }
15299}
15300
15301impl SocketSetIpv6ReceiveTrafficClassResponder {
15302    /// Sends a response to the FIDL transaction.
15303    ///
15304    /// Sets the channel to shutdown if an error occurs.
15305    pub fn send(
15306        self,
15307        mut result: Result<(), fidl_fuchsia_posix::Errno>,
15308    ) -> Result<(), fidl::Error> {
15309        let _result = self.send_raw(result);
15310        if _result.is_err() {
15311            self.control_handle.shutdown();
15312        }
15313        self.drop_without_shutdown();
15314        _result
15315    }
15316
15317    /// Similar to "send" but does not shutdown the channel if an error occurs.
15318    pub fn send_no_shutdown_on_err(
15319        self,
15320        mut result: Result<(), fidl_fuchsia_posix::Errno>,
15321    ) -> Result<(), fidl::Error> {
15322        let _result = self.send_raw(result);
15323        self.drop_without_shutdown();
15324        _result
15325    }
15326
15327    fn send_raw(
15328        &self,
15329        mut result: Result<(), fidl_fuchsia_posix::Errno>,
15330    ) -> Result<(), fidl::Error> {
15331        self.control_handle.inner.send::<fidl::encoding::ResultType<
15332            fidl::encoding::EmptyStruct,
15333            fidl_fuchsia_posix::Errno,
15334        >>(
15335            result,
15336            self.tx_id,
15337            0x58f07c8788d099a0,
15338            fidl::encoding::DynamicFlags::empty(),
15339        )
15340    }
15341}
15342
15343#[must_use = "FIDL methods require a response to be sent"]
15344#[derive(Debug)]
15345pub struct SocketGetIpv6ReceiveTrafficClassResponder {
15346    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
15347    tx_id: u32,
15348}
15349
15350/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
15351/// if the responder is dropped without sending a response, so that the client
15352/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
15353impl std::ops::Drop for SocketGetIpv6ReceiveTrafficClassResponder {
15354    fn drop(&mut self) {
15355        self.control_handle.shutdown();
15356        // Safety: drops once, never accessed again
15357        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15358    }
15359}
15360
15361impl fidl::endpoints::Responder for SocketGetIpv6ReceiveTrafficClassResponder {
15362    type ControlHandle = SocketControlHandle;
15363
15364    fn control_handle(&self) -> &SocketControlHandle {
15365        &self.control_handle
15366    }
15367
15368    fn drop_without_shutdown(mut self) {
15369        // Safety: drops once, never accessed again due to mem::forget
15370        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15371        // Prevent Drop from running (which would shut down the channel)
15372        std::mem::forget(self);
15373    }
15374}
15375
15376impl SocketGetIpv6ReceiveTrafficClassResponder {
15377    /// Sends a response to the FIDL transaction.
15378    ///
15379    /// Sets the channel to shutdown if an error occurs.
15380    pub fn send(
15381        self,
15382        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
15383    ) -> Result<(), fidl::Error> {
15384        let _result = self.send_raw(result);
15385        if _result.is_err() {
15386            self.control_handle.shutdown();
15387        }
15388        self.drop_without_shutdown();
15389        _result
15390    }
15391
15392    /// Similar to "send" but does not shutdown the channel if an error occurs.
15393    pub fn send_no_shutdown_on_err(
15394        self,
15395        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
15396    ) -> Result<(), fidl::Error> {
15397        let _result = self.send_raw(result);
15398        self.drop_without_shutdown();
15399        _result
15400    }
15401
15402    fn send_raw(
15403        &self,
15404        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
15405    ) -> Result<(), fidl::Error> {
15406        self.control_handle.inner.send::<fidl::encoding::ResultType<
15407            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
15408            fidl_fuchsia_posix::Errno,
15409        >>(
15410            result.map(|value| (value,)),
15411            self.tx_id,
15412            0x2e334df1da553ffa,
15413            fidl::encoding::DynamicFlags::empty(),
15414        )
15415    }
15416}
15417
15418#[must_use = "FIDL methods require a response to be sent"]
15419#[derive(Debug)]
15420pub struct SocketSetIpv6TrafficClassResponder {
15421    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
15422    tx_id: u32,
15423}
15424
15425/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
15426/// if the responder is dropped without sending a response, so that the client
15427/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
15428impl std::ops::Drop for SocketSetIpv6TrafficClassResponder {
15429    fn drop(&mut self) {
15430        self.control_handle.shutdown();
15431        // Safety: drops once, never accessed again
15432        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15433    }
15434}
15435
15436impl fidl::endpoints::Responder for SocketSetIpv6TrafficClassResponder {
15437    type ControlHandle = SocketControlHandle;
15438
15439    fn control_handle(&self) -> &SocketControlHandle {
15440        &self.control_handle
15441    }
15442
15443    fn drop_without_shutdown(mut self) {
15444        // Safety: drops once, never accessed again due to mem::forget
15445        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15446        // Prevent Drop from running (which would shut down the channel)
15447        std::mem::forget(self);
15448    }
15449}
15450
15451impl SocketSetIpv6TrafficClassResponder {
15452    /// Sends a response to the FIDL transaction.
15453    ///
15454    /// Sets the channel to shutdown if an error occurs.
15455    pub fn send(
15456        self,
15457        mut result: Result<(), fidl_fuchsia_posix::Errno>,
15458    ) -> Result<(), fidl::Error> {
15459        let _result = self.send_raw(result);
15460        if _result.is_err() {
15461            self.control_handle.shutdown();
15462        }
15463        self.drop_without_shutdown();
15464        _result
15465    }
15466
15467    /// Similar to "send" but does not shutdown the channel if an error occurs.
15468    pub fn send_no_shutdown_on_err(
15469        self,
15470        mut result: Result<(), fidl_fuchsia_posix::Errno>,
15471    ) -> Result<(), fidl::Error> {
15472        let _result = self.send_raw(result);
15473        self.drop_without_shutdown();
15474        _result
15475    }
15476
15477    fn send_raw(
15478        &self,
15479        mut result: Result<(), fidl_fuchsia_posix::Errno>,
15480    ) -> Result<(), fidl::Error> {
15481        self.control_handle.inner.send::<fidl::encoding::ResultType<
15482            fidl::encoding::EmptyStruct,
15483            fidl_fuchsia_posix::Errno,
15484        >>(
15485            result,
15486            self.tx_id,
15487            0x6af077800c5a0b4f,
15488            fidl::encoding::DynamicFlags::empty(),
15489        )
15490    }
15491}
15492
15493#[must_use = "FIDL methods require a response to be sent"]
15494#[derive(Debug)]
15495pub struct SocketGetIpv6TrafficClassResponder {
15496    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
15497    tx_id: u32,
15498}
15499
15500/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
15501/// if the responder is dropped without sending a response, so that the client
15502/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
15503impl std::ops::Drop for SocketGetIpv6TrafficClassResponder {
15504    fn drop(&mut self) {
15505        self.control_handle.shutdown();
15506        // Safety: drops once, never accessed again
15507        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15508    }
15509}
15510
15511impl fidl::endpoints::Responder for SocketGetIpv6TrafficClassResponder {
15512    type ControlHandle = SocketControlHandle;
15513
15514    fn control_handle(&self) -> &SocketControlHandle {
15515        &self.control_handle
15516    }
15517
15518    fn drop_without_shutdown(mut self) {
15519        // Safety: drops once, never accessed again due to mem::forget
15520        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15521        // Prevent Drop from running (which would shut down the channel)
15522        std::mem::forget(self);
15523    }
15524}
15525
15526impl SocketGetIpv6TrafficClassResponder {
15527    /// Sends a response to the FIDL transaction.
15528    ///
15529    /// Sets the channel to shutdown if an error occurs.
15530    pub fn send(
15531        self,
15532        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
15533    ) -> Result<(), fidl::Error> {
15534        let _result = self.send_raw(result);
15535        if _result.is_err() {
15536            self.control_handle.shutdown();
15537        }
15538        self.drop_without_shutdown();
15539        _result
15540    }
15541
15542    /// Similar to "send" but does not shutdown the channel if an error occurs.
15543    pub fn send_no_shutdown_on_err(
15544        self,
15545        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
15546    ) -> Result<(), fidl::Error> {
15547        let _result = self.send_raw(result);
15548        self.drop_without_shutdown();
15549        _result
15550    }
15551
15552    fn send_raw(
15553        &self,
15554        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
15555    ) -> Result<(), fidl::Error> {
15556        self.control_handle.inner.send::<fidl::encoding::ResultType<
15557            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6TrafficClassResponse,
15558            fidl_fuchsia_posix::Errno,
15559        >>(
15560            result.map(|value| (value,)),
15561            self.tx_id,
15562            0x6baf6eed8fc2f04,
15563            fidl::encoding::DynamicFlags::empty(),
15564        )
15565    }
15566}
15567
15568#[must_use = "FIDL methods require a response to be sent"]
15569#[derive(Debug)]
15570pub struct SocketSetIpv6ReceivePacketInfoResponder {
15571    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
15572    tx_id: u32,
15573}
15574
15575/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
15576/// if the responder is dropped without sending a response, so that the client
15577/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
15578impl std::ops::Drop for SocketSetIpv6ReceivePacketInfoResponder {
15579    fn drop(&mut self) {
15580        self.control_handle.shutdown();
15581        // Safety: drops once, never accessed again
15582        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15583    }
15584}
15585
15586impl fidl::endpoints::Responder for SocketSetIpv6ReceivePacketInfoResponder {
15587    type ControlHandle = SocketControlHandle;
15588
15589    fn control_handle(&self) -> &SocketControlHandle {
15590        &self.control_handle
15591    }
15592
15593    fn drop_without_shutdown(mut self) {
15594        // Safety: drops once, never accessed again due to mem::forget
15595        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15596        // Prevent Drop from running (which would shut down the channel)
15597        std::mem::forget(self);
15598    }
15599}
15600
15601impl SocketSetIpv6ReceivePacketInfoResponder {
15602    /// Sends a response to the FIDL transaction.
15603    ///
15604    /// Sets the channel to shutdown if an error occurs.
15605    pub fn send(
15606        self,
15607        mut result: Result<(), fidl_fuchsia_posix::Errno>,
15608    ) -> Result<(), fidl::Error> {
15609        let _result = self.send_raw(result);
15610        if _result.is_err() {
15611            self.control_handle.shutdown();
15612        }
15613        self.drop_without_shutdown();
15614        _result
15615    }
15616
15617    /// Similar to "send" but does not shutdown the channel if an error occurs.
15618    pub fn send_no_shutdown_on_err(
15619        self,
15620        mut result: Result<(), fidl_fuchsia_posix::Errno>,
15621    ) -> Result<(), fidl::Error> {
15622        let _result = self.send_raw(result);
15623        self.drop_without_shutdown();
15624        _result
15625    }
15626
15627    fn send_raw(
15628        &self,
15629        mut result: Result<(), fidl_fuchsia_posix::Errno>,
15630    ) -> Result<(), fidl::Error> {
15631        self.control_handle.inner.send::<fidl::encoding::ResultType<
15632            fidl::encoding::EmptyStruct,
15633            fidl_fuchsia_posix::Errno,
15634        >>(
15635            result,
15636            self.tx_id,
15637            0x19259775b1a92768,
15638            fidl::encoding::DynamicFlags::empty(),
15639        )
15640    }
15641}
15642
15643#[must_use = "FIDL methods require a response to be sent"]
15644#[derive(Debug)]
15645pub struct SocketGetIpv6ReceivePacketInfoResponder {
15646    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
15647    tx_id: u32,
15648}
15649
15650/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
15651/// if the responder is dropped without sending a response, so that the client
15652/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
15653impl std::ops::Drop for SocketGetIpv6ReceivePacketInfoResponder {
15654    fn drop(&mut self) {
15655        self.control_handle.shutdown();
15656        // Safety: drops once, never accessed again
15657        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15658    }
15659}
15660
15661impl fidl::endpoints::Responder for SocketGetIpv6ReceivePacketInfoResponder {
15662    type ControlHandle = SocketControlHandle;
15663
15664    fn control_handle(&self) -> &SocketControlHandle {
15665        &self.control_handle
15666    }
15667
15668    fn drop_without_shutdown(mut self) {
15669        // Safety: drops once, never accessed again due to mem::forget
15670        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15671        // Prevent Drop from running (which would shut down the channel)
15672        std::mem::forget(self);
15673    }
15674}
15675
15676impl SocketGetIpv6ReceivePacketInfoResponder {
15677    /// Sends a response to the FIDL transaction.
15678    ///
15679    /// Sets the channel to shutdown if an error occurs.
15680    pub fn send(
15681        self,
15682        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
15683    ) -> Result<(), fidl::Error> {
15684        let _result = self.send_raw(result);
15685        if _result.is_err() {
15686            self.control_handle.shutdown();
15687        }
15688        self.drop_without_shutdown();
15689        _result
15690    }
15691
15692    /// Similar to "send" but does not shutdown the channel if an error occurs.
15693    pub fn send_no_shutdown_on_err(
15694        self,
15695        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
15696    ) -> Result<(), fidl::Error> {
15697        let _result = self.send_raw(result);
15698        self.drop_without_shutdown();
15699        _result
15700    }
15701
15702    fn send_raw(
15703        &self,
15704        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
15705    ) -> Result<(), fidl::Error> {
15706        self.control_handle.inner.send::<fidl::encoding::ResultType<
15707            fidl_fuchsia_posix_socket::BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
15708            fidl_fuchsia_posix::Errno,
15709        >>(
15710            result.map(|value| (value,)),
15711            self.tx_id,
15712            0x7acd4a2775baec75,
15713            fidl::encoding::DynamicFlags::empty(),
15714        )
15715    }
15716}
15717
15718#[must_use = "FIDL methods require a response to be sent"]
15719#[derive(Debug)]
15720pub struct SocketGetOriginalDestinationResponder {
15721    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
15722    tx_id: u32,
15723}
15724
15725/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
15726/// if the responder is dropped without sending a response, so that the client
15727/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
15728impl std::ops::Drop for SocketGetOriginalDestinationResponder {
15729    fn drop(&mut self) {
15730        self.control_handle.shutdown();
15731        // Safety: drops once, never accessed again
15732        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15733    }
15734}
15735
15736impl fidl::endpoints::Responder for SocketGetOriginalDestinationResponder {
15737    type ControlHandle = SocketControlHandle;
15738
15739    fn control_handle(&self) -> &SocketControlHandle {
15740        &self.control_handle
15741    }
15742
15743    fn drop_without_shutdown(mut self) {
15744        // Safety: drops once, never accessed again due to mem::forget
15745        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15746        // Prevent Drop from running (which would shut down the channel)
15747        std::mem::forget(self);
15748    }
15749}
15750
15751impl SocketGetOriginalDestinationResponder {
15752    /// Sends a response to the FIDL transaction.
15753    ///
15754    /// Sets the channel to shutdown if an error occurs.
15755    pub fn send(
15756        self,
15757        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
15758    ) -> Result<(), fidl::Error> {
15759        let _result = self.send_raw(result);
15760        if _result.is_err() {
15761            self.control_handle.shutdown();
15762        }
15763        self.drop_without_shutdown();
15764        _result
15765    }
15766
15767    /// Similar to "send" but does not shutdown the channel if an error occurs.
15768    pub fn send_no_shutdown_on_err(
15769        self,
15770        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
15771    ) -> Result<(), fidl::Error> {
15772        let _result = self.send_raw(result);
15773        self.drop_without_shutdown();
15774        _result
15775    }
15776
15777    fn send_raw(
15778        &self,
15779        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
15780    ) -> Result<(), fidl::Error> {
15781        self.control_handle.inner.send::<fidl::encoding::ResultType<
15782            fidl_fuchsia_posix_socket::BaseNetworkSocketGetOriginalDestinationResponse,
15783            fidl_fuchsia_posix::Errno,
15784        >>(
15785            result.map(|value| (value,)),
15786            self.tx_id,
15787            0x38bf28f0dafdbac0,
15788            fidl::encoding::DynamicFlags::empty(),
15789        )
15790    }
15791}
15792
15793#[must_use = "FIDL methods require a response to be sent"]
15794#[derive(Debug)]
15795pub struct SocketDescribeResponder {
15796    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
15797    tx_id: u32,
15798}
15799
15800/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
15801/// if the responder is dropped without sending a response, so that the client
15802/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
15803impl std::ops::Drop for SocketDescribeResponder {
15804    fn drop(&mut self) {
15805        self.control_handle.shutdown();
15806        // Safety: drops once, never accessed again
15807        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15808    }
15809}
15810
15811impl fidl::endpoints::Responder for SocketDescribeResponder {
15812    type ControlHandle = SocketControlHandle;
15813
15814    fn control_handle(&self) -> &SocketControlHandle {
15815        &self.control_handle
15816    }
15817
15818    fn drop_without_shutdown(mut self) {
15819        // Safety: drops once, never accessed again due to mem::forget
15820        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15821        // Prevent Drop from running (which would shut down the channel)
15822        std::mem::forget(self);
15823    }
15824}
15825
15826impl SocketDescribeResponder {
15827    /// Sends a response to the FIDL transaction.
15828    ///
15829    /// Sets the channel to shutdown if an error occurs.
15830    pub fn send(self, mut payload: SocketDescribeResponse) -> Result<(), fidl::Error> {
15831        let _result = self.send_raw(payload);
15832        if _result.is_err() {
15833            self.control_handle.shutdown();
15834        }
15835        self.drop_without_shutdown();
15836        _result
15837    }
15838
15839    /// Similar to "send" but does not shutdown the channel if an error occurs.
15840    pub fn send_no_shutdown_on_err(
15841        self,
15842        mut payload: SocketDescribeResponse,
15843    ) -> Result<(), fidl::Error> {
15844        let _result = self.send_raw(payload);
15845        self.drop_without_shutdown();
15846        _result
15847    }
15848
15849    fn send_raw(&self, mut payload: SocketDescribeResponse) -> Result<(), fidl::Error> {
15850        self.control_handle.inner.send::<SocketDescribeResponse>(
15851            &mut payload,
15852            self.tx_id,
15853            0x335706eccf54a135,
15854            fidl::encoding::DynamicFlags::empty(),
15855        )
15856    }
15857}
15858
15859#[must_use = "FIDL methods require a response to be sent"]
15860#[derive(Debug)]
15861pub struct SocketRecvMsgResponder {
15862    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
15863    tx_id: u32,
15864}
15865
15866/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
15867/// if the responder is dropped without sending a response, so that the client
15868/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
15869impl std::ops::Drop for SocketRecvMsgResponder {
15870    fn drop(&mut self) {
15871        self.control_handle.shutdown();
15872        // Safety: drops once, never accessed again
15873        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15874    }
15875}
15876
15877impl fidl::endpoints::Responder for SocketRecvMsgResponder {
15878    type ControlHandle = SocketControlHandle;
15879
15880    fn control_handle(&self) -> &SocketControlHandle {
15881        &self.control_handle
15882    }
15883
15884    fn drop_without_shutdown(mut self) {
15885        // Safety: drops once, never accessed again due to mem::forget
15886        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15887        // Prevent Drop from running (which would shut down the channel)
15888        std::mem::forget(self);
15889    }
15890}
15891
15892impl SocketRecvMsgResponder {
15893    /// Sends a response to the FIDL transaction.
15894    ///
15895    /// Sets the channel to shutdown if an error occurs.
15896    pub fn send(
15897        self,
15898        mut result: Result<
15899            (
15900                Option<&fidl_fuchsia_net::SocketAddress>,
15901                &[u8],
15902                &fidl_fuchsia_posix_socket::NetworkSocketRecvControlData,
15903                u32,
15904            ),
15905            fidl_fuchsia_posix::Errno,
15906        >,
15907    ) -> Result<(), fidl::Error> {
15908        let _result = self.send_raw(result);
15909        if _result.is_err() {
15910            self.control_handle.shutdown();
15911        }
15912        self.drop_without_shutdown();
15913        _result
15914    }
15915
15916    /// Similar to "send" but does not shutdown the channel if an error occurs.
15917    pub fn send_no_shutdown_on_err(
15918        self,
15919        mut result: Result<
15920            (
15921                Option<&fidl_fuchsia_net::SocketAddress>,
15922                &[u8],
15923                &fidl_fuchsia_posix_socket::NetworkSocketRecvControlData,
15924                u32,
15925            ),
15926            fidl_fuchsia_posix::Errno,
15927        >,
15928    ) -> Result<(), fidl::Error> {
15929        let _result = self.send_raw(result);
15930        self.drop_without_shutdown();
15931        _result
15932    }
15933
15934    fn send_raw(
15935        &self,
15936        mut result: Result<
15937            (
15938                Option<&fidl_fuchsia_net::SocketAddress>,
15939                &[u8],
15940                &fidl_fuchsia_posix_socket::NetworkSocketRecvControlData,
15941                u32,
15942            ),
15943            fidl_fuchsia_posix::Errno,
15944        >,
15945    ) -> Result<(), fidl::Error> {
15946        self.control_handle.inner.send::<fidl::encoding::ResultType<
15947            SocketRecvMsgResponse,
15948            fidl_fuchsia_posix::Errno,
15949        >>(
15950            result,
15951            self.tx_id,
15952            0x1dfb695351d3aa1d,
15953            fidl::encoding::DynamicFlags::empty(),
15954        )
15955    }
15956}
15957
15958#[must_use = "FIDL methods require a response to be sent"]
15959#[derive(Debug)]
15960pub struct SocketSendMsgResponder {
15961    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
15962    tx_id: u32,
15963}
15964
15965/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
15966/// if the responder is dropped without sending a response, so that the client
15967/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
15968impl std::ops::Drop for SocketSendMsgResponder {
15969    fn drop(&mut self) {
15970        self.control_handle.shutdown();
15971        // Safety: drops once, never accessed again
15972        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15973    }
15974}
15975
15976impl fidl::endpoints::Responder for SocketSendMsgResponder {
15977    type ControlHandle = SocketControlHandle;
15978
15979    fn control_handle(&self) -> &SocketControlHandle {
15980        &self.control_handle
15981    }
15982
15983    fn drop_without_shutdown(mut self) {
15984        // Safety: drops once, never accessed again due to mem::forget
15985        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
15986        // Prevent Drop from running (which would shut down the channel)
15987        std::mem::forget(self);
15988    }
15989}
15990
15991impl SocketSendMsgResponder {
15992    /// Sends a response to the FIDL transaction.
15993    ///
15994    /// Sets the channel to shutdown if an error occurs.
15995    pub fn send(
15996        self,
15997        mut result: Result<(), fidl_fuchsia_posix::Errno>,
15998    ) -> Result<(), fidl::Error> {
15999        let _result = self.send_raw(result);
16000        if _result.is_err() {
16001            self.control_handle.shutdown();
16002        }
16003        self.drop_without_shutdown();
16004        _result
16005    }
16006
16007    /// Similar to "send" but does not shutdown the channel if an error occurs.
16008    pub fn send_no_shutdown_on_err(
16009        self,
16010        mut result: Result<(), fidl_fuchsia_posix::Errno>,
16011    ) -> Result<(), fidl::Error> {
16012        let _result = self.send_raw(result);
16013        self.drop_without_shutdown();
16014        _result
16015    }
16016
16017    fn send_raw(
16018        &self,
16019        mut result: Result<(), fidl_fuchsia_posix::Errno>,
16020    ) -> Result<(), fidl::Error> {
16021        self.control_handle.inner.send::<fidl::encoding::ResultType<
16022            fidl::encoding::EmptyStruct,
16023            fidl_fuchsia_posix::Errno,
16024        >>(
16025            result,
16026            self.tx_id,
16027            0x2cf1eac9a7fc8958,
16028            fidl::encoding::DynamicFlags::empty(),
16029        )
16030    }
16031}
16032
16033#[must_use = "FIDL methods require a response to be sent"]
16034#[derive(Debug)]
16035pub struct SocketGetInfoResponder {
16036    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
16037    tx_id: u32,
16038}
16039
16040/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
16041/// if the responder is dropped without sending a response, so that the client
16042/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
16043impl std::ops::Drop for SocketGetInfoResponder {
16044    fn drop(&mut self) {
16045        self.control_handle.shutdown();
16046        // Safety: drops once, never accessed again
16047        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
16048    }
16049}
16050
16051impl fidl::endpoints::Responder for SocketGetInfoResponder {
16052    type ControlHandle = SocketControlHandle;
16053
16054    fn control_handle(&self) -> &SocketControlHandle {
16055        &self.control_handle
16056    }
16057
16058    fn drop_without_shutdown(mut self) {
16059        // Safety: drops once, never accessed again due to mem::forget
16060        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
16061        // Prevent Drop from running (which would shut down the channel)
16062        std::mem::forget(self);
16063    }
16064}
16065
16066impl SocketGetInfoResponder {
16067    /// Sends a response to the FIDL transaction.
16068    ///
16069    /// Sets the channel to shutdown if an error occurs.
16070    pub fn send(
16071        self,
16072        mut result: Result<
16073            (fidl_fuchsia_posix_socket::Domain, &ProtocolAssociation),
16074            fidl_fuchsia_posix::Errno,
16075        >,
16076    ) -> Result<(), fidl::Error> {
16077        let _result = self.send_raw(result);
16078        if _result.is_err() {
16079            self.control_handle.shutdown();
16080        }
16081        self.drop_without_shutdown();
16082        _result
16083    }
16084
16085    /// Similar to "send" but does not shutdown the channel if an error occurs.
16086    pub fn send_no_shutdown_on_err(
16087        self,
16088        mut result: Result<
16089            (fidl_fuchsia_posix_socket::Domain, &ProtocolAssociation),
16090            fidl_fuchsia_posix::Errno,
16091        >,
16092    ) -> Result<(), fidl::Error> {
16093        let _result = self.send_raw(result);
16094        self.drop_without_shutdown();
16095        _result
16096    }
16097
16098    fn send_raw(
16099        &self,
16100        mut result: Result<
16101            (fidl_fuchsia_posix_socket::Domain, &ProtocolAssociation),
16102            fidl_fuchsia_posix::Errno,
16103        >,
16104    ) -> Result<(), fidl::Error> {
16105        self.control_handle.inner.send::<fidl::encoding::ResultType<
16106            SocketGetInfoResponse,
16107            fidl_fuchsia_posix::Errno,
16108        >>(
16109            result,
16110            self.tx_id,
16111            0x39676f75aec339ba,
16112            fidl::encoding::DynamicFlags::empty(),
16113        )
16114    }
16115}
16116
16117#[must_use = "FIDL methods require a response to be sent"]
16118#[derive(Debug)]
16119pub struct SocketSetIpHeaderIncludedResponder {
16120    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
16121    tx_id: u32,
16122}
16123
16124/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
16125/// if the responder is dropped without sending a response, so that the client
16126/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
16127impl std::ops::Drop for SocketSetIpHeaderIncludedResponder {
16128    fn drop(&mut self) {
16129        self.control_handle.shutdown();
16130        // Safety: drops once, never accessed again
16131        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
16132    }
16133}
16134
16135impl fidl::endpoints::Responder for SocketSetIpHeaderIncludedResponder {
16136    type ControlHandle = SocketControlHandle;
16137
16138    fn control_handle(&self) -> &SocketControlHandle {
16139        &self.control_handle
16140    }
16141
16142    fn drop_without_shutdown(mut self) {
16143        // Safety: drops once, never accessed again due to mem::forget
16144        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
16145        // Prevent Drop from running (which would shut down the channel)
16146        std::mem::forget(self);
16147    }
16148}
16149
16150impl SocketSetIpHeaderIncludedResponder {
16151    /// Sends a response to the FIDL transaction.
16152    ///
16153    /// Sets the channel to shutdown if an error occurs.
16154    pub fn send(
16155        self,
16156        mut result: Result<(), fidl_fuchsia_posix::Errno>,
16157    ) -> Result<(), fidl::Error> {
16158        let _result = self.send_raw(result);
16159        if _result.is_err() {
16160            self.control_handle.shutdown();
16161        }
16162        self.drop_without_shutdown();
16163        _result
16164    }
16165
16166    /// Similar to "send" but does not shutdown the channel if an error occurs.
16167    pub fn send_no_shutdown_on_err(
16168        self,
16169        mut result: Result<(), fidl_fuchsia_posix::Errno>,
16170    ) -> Result<(), fidl::Error> {
16171        let _result = self.send_raw(result);
16172        self.drop_without_shutdown();
16173        _result
16174    }
16175
16176    fn send_raw(
16177        &self,
16178        mut result: Result<(), fidl_fuchsia_posix::Errno>,
16179    ) -> Result<(), fidl::Error> {
16180        self.control_handle.inner.send::<fidl::encoding::ResultType<
16181            fidl::encoding::EmptyStruct,
16182            fidl_fuchsia_posix::Errno,
16183        >>(
16184            result,
16185            self.tx_id,
16186            0x5d06a606d95e8f3,
16187            fidl::encoding::DynamicFlags::empty(),
16188        )
16189    }
16190}
16191
16192#[must_use = "FIDL methods require a response to be sent"]
16193#[derive(Debug)]
16194pub struct SocketGetIpHeaderIncludedResponder {
16195    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
16196    tx_id: u32,
16197}
16198
16199/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
16200/// if the responder is dropped without sending a response, so that the client
16201/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
16202impl std::ops::Drop for SocketGetIpHeaderIncludedResponder {
16203    fn drop(&mut self) {
16204        self.control_handle.shutdown();
16205        // Safety: drops once, never accessed again
16206        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
16207    }
16208}
16209
16210impl fidl::endpoints::Responder for SocketGetIpHeaderIncludedResponder {
16211    type ControlHandle = SocketControlHandle;
16212
16213    fn control_handle(&self) -> &SocketControlHandle {
16214        &self.control_handle
16215    }
16216
16217    fn drop_without_shutdown(mut self) {
16218        // Safety: drops once, never accessed again due to mem::forget
16219        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
16220        // Prevent Drop from running (which would shut down the channel)
16221        std::mem::forget(self);
16222    }
16223}
16224
16225impl SocketGetIpHeaderIncludedResponder {
16226    /// Sends a response to the FIDL transaction.
16227    ///
16228    /// Sets the channel to shutdown if an error occurs.
16229    pub fn send(
16230        self,
16231        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
16232    ) -> Result<(), fidl::Error> {
16233        let _result = self.send_raw(result);
16234        if _result.is_err() {
16235            self.control_handle.shutdown();
16236        }
16237        self.drop_without_shutdown();
16238        _result
16239    }
16240
16241    /// Similar to "send" but does not shutdown the channel if an error occurs.
16242    pub fn send_no_shutdown_on_err(
16243        self,
16244        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
16245    ) -> Result<(), fidl::Error> {
16246        let _result = self.send_raw(result);
16247        self.drop_without_shutdown();
16248        _result
16249    }
16250
16251    fn send_raw(
16252        &self,
16253        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
16254    ) -> Result<(), fidl::Error> {
16255        self.control_handle.inner.send::<fidl::encoding::ResultType<
16256            SocketGetIpHeaderIncludedResponse,
16257            fidl_fuchsia_posix::Errno,
16258        >>(
16259            result.map(|value| (value,)),
16260            self.tx_id,
16261            0x76125ad1f4d175f6,
16262            fidl::encoding::DynamicFlags::empty(),
16263        )
16264    }
16265}
16266
16267#[must_use = "FIDL methods require a response to be sent"]
16268#[derive(Debug)]
16269pub struct SocketSetIcmpv6FilterResponder {
16270    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
16271    tx_id: u32,
16272}
16273
16274/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
16275/// if the responder is dropped without sending a response, so that the client
16276/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
16277impl std::ops::Drop for SocketSetIcmpv6FilterResponder {
16278    fn drop(&mut self) {
16279        self.control_handle.shutdown();
16280        // Safety: drops once, never accessed again
16281        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
16282    }
16283}
16284
16285impl fidl::endpoints::Responder for SocketSetIcmpv6FilterResponder {
16286    type ControlHandle = SocketControlHandle;
16287
16288    fn control_handle(&self) -> &SocketControlHandle {
16289        &self.control_handle
16290    }
16291
16292    fn drop_without_shutdown(mut self) {
16293        // Safety: drops once, never accessed again due to mem::forget
16294        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
16295        // Prevent Drop from running (which would shut down the channel)
16296        std::mem::forget(self);
16297    }
16298}
16299
16300impl SocketSetIcmpv6FilterResponder {
16301    /// Sends a response to the FIDL transaction.
16302    ///
16303    /// Sets the channel to shutdown if an error occurs.
16304    pub fn send(
16305        self,
16306        mut result: Result<(), fidl_fuchsia_posix::Errno>,
16307    ) -> Result<(), fidl::Error> {
16308        let _result = self.send_raw(result);
16309        if _result.is_err() {
16310            self.control_handle.shutdown();
16311        }
16312        self.drop_without_shutdown();
16313        _result
16314    }
16315
16316    /// Similar to "send" but does not shutdown the channel if an error occurs.
16317    pub fn send_no_shutdown_on_err(
16318        self,
16319        mut result: Result<(), fidl_fuchsia_posix::Errno>,
16320    ) -> Result<(), fidl::Error> {
16321        let _result = self.send_raw(result);
16322        self.drop_without_shutdown();
16323        _result
16324    }
16325
16326    fn send_raw(
16327        &self,
16328        mut result: Result<(), fidl_fuchsia_posix::Errno>,
16329    ) -> Result<(), fidl::Error> {
16330        self.control_handle.inner.send::<fidl::encoding::ResultType<
16331            fidl::encoding::EmptyStruct,
16332            fidl_fuchsia_posix::Errno,
16333        >>(
16334            result,
16335            self.tx_id,
16336            0x4ebea92a43ae68a9,
16337            fidl::encoding::DynamicFlags::empty(),
16338        )
16339    }
16340}
16341
16342#[must_use = "FIDL methods require a response to be sent"]
16343#[derive(Debug)]
16344pub struct SocketGetIcmpv6FilterResponder {
16345    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
16346    tx_id: u32,
16347}
16348
16349/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
16350/// if the responder is dropped without sending a response, so that the client
16351/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
16352impl std::ops::Drop for SocketGetIcmpv6FilterResponder {
16353    fn drop(&mut self) {
16354        self.control_handle.shutdown();
16355        // Safety: drops once, never accessed again
16356        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
16357    }
16358}
16359
16360impl fidl::endpoints::Responder for SocketGetIcmpv6FilterResponder {
16361    type ControlHandle = SocketControlHandle;
16362
16363    fn control_handle(&self) -> &SocketControlHandle {
16364        &self.control_handle
16365    }
16366
16367    fn drop_without_shutdown(mut self) {
16368        // Safety: drops once, never accessed again due to mem::forget
16369        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
16370        // Prevent Drop from running (which would shut down the channel)
16371        std::mem::forget(self);
16372    }
16373}
16374
16375impl SocketGetIcmpv6FilterResponder {
16376    /// Sends a response to the FIDL transaction.
16377    ///
16378    /// Sets the channel to shutdown if an error occurs.
16379    pub fn send(
16380        self,
16381        mut result: Result<&Icmpv6Filter, fidl_fuchsia_posix::Errno>,
16382    ) -> Result<(), fidl::Error> {
16383        let _result = self.send_raw(result);
16384        if _result.is_err() {
16385            self.control_handle.shutdown();
16386        }
16387        self.drop_without_shutdown();
16388        _result
16389    }
16390
16391    /// Similar to "send" but does not shutdown the channel if an error occurs.
16392    pub fn send_no_shutdown_on_err(
16393        self,
16394        mut result: Result<&Icmpv6Filter, fidl_fuchsia_posix::Errno>,
16395    ) -> Result<(), fidl::Error> {
16396        let _result = self.send_raw(result);
16397        self.drop_without_shutdown();
16398        _result
16399    }
16400
16401    fn send_raw(
16402        &self,
16403        mut result: Result<&Icmpv6Filter, fidl_fuchsia_posix::Errno>,
16404    ) -> Result<(), fidl::Error> {
16405        self.control_handle.inner.send::<fidl::encoding::ResultType<
16406            SocketGetIcmpv6FilterResponse,
16407            fidl_fuchsia_posix::Errno,
16408        >>(
16409            result.map(|filter| (filter,)),
16410            self.tx_id,
16411            0x43bd4f3bc0970ace,
16412            fidl::encoding::DynamicFlags::empty(),
16413        )
16414    }
16415}
16416
16417#[must_use = "FIDL methods require a response to be sent"]
16418#[derive(Debug)]
16419pub struct SocketSetIpv6ChecksumResponder {
16420    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
16421    tx_id: u32,
16422}
16423
16424/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
16425/// if the responder is dropped without sending a response, so that the client
16426/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
16427impl std::ops::Drop for SocketSetIpv6ChecksumResponder {
16428    fn drop(&mut self) {
16429        self.control_handle.shutdown();
16430        // Safety: drops once, never accessed again
16431        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
16432    }
16433}
16434
16435impl fidl::endpoints::Responder for SocketSetIpv6ChecksumResponder {
16436    type ControlHandle = SocketControlHandle;
16437
16438    fn control_handle(&self) -> &SocketControlHandle {
16439        &self.control_handle
16440    }
16441
16442    fn drop_without_shutdown(mut self) {
16443        // Safety: drops once, never accessed again due to mem::forget
16444        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
16445        // Prevent Drop from running (which would shut down the channel)
16446        std::mem::forget(self);
16447    }
16448}
16449
16450impl SocketSetIpv6ChecksumResponder {
16451    /// Sends a response to the FIDL transaction.
16452    ///
16453    /// Sets the channel to shutdown if an error occurs.
16454    pub fn send(
16455        self,
16456        mut result: Result<(), fidl_fuchsia_posix::Errno>,
16457    ) -> Result<(), fidl::Error> {
16458        let _result = self.send_raw(result);
16459        if _result.is_err() {
16460            self.control_handle.shutdown();
16461        }
16462        self.drop_without_shutdown();
16463        _result
16464    }
16465
16466    /// Similar to "send" but does not shutdown the channel if an error occurs.
16467    pub fn send_no_shutdown_on_err(
16468        self,
16469        mut result: Result<(), fidl_fuchsia_posix::Errno>,
16470    ) -> Result<(), fidl::Error> {
16471        let _result = self.send_raw(result);
16472        self.drop_without_shutdown();
16473        _result
16474    }
16475
16476    fn send_raw(
16477        &self,
16478        mut result: Result<(), fidl_fuchsia_posix::Errno>,
16479    ) -> Result<(), fidl::Error> {
16480        self.control_handle.inner.send::<fidl::encoding::ResultType<
16481            fidl::encoding::EmptyStruct,
16482            fidl_fuchsia_posix::Errno,
16483        >>(
16484            result,
16485            self.tx_id,
16486            0x18b7809577199cb4,
16487            fidl::encoding::DynamicFlags::empty(),
16488        )
16489    }
16490}
16491
16492#[must_use = "FIDL methods require a response to be sent"]
16493#[derive(Debug)]
16494pub struct SocketGetIpv6ChecksumResponder {
16495    control_handle: std::mem::ManuallyDrop<SocketControlHandle>,
16496    tx_id: u32,
16497}
16498
16499/// Set the the channel to be shutdown (see [`SocketControlHandle::shutdown`])
16500/// if the responder is dropped without sending a response, so that the client
16501/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
16502impl std::ops::Drop for SocketGetIpv6ChecksumResponder {
16503    fn drop(&mut self) {
16504        self.control_handle.shutdown();
16505        // Safety: drops once, never accessed again
16506        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
16507    }
16508}
16509
16510impl fidl::endpoints::Responder for SocketGetIpv6ChecksumResponder {
16511    type ControlHandle = SocketControlHandle;
16512
16513    fn control_handle(&self) -> &SocketControlHandle {
16514        &self.control_handle
16515    }
16516
16517    fn drop_without_shutdown(mut self) {
16518        // Safety: drops once, never accessed again due to mem::forget
16519        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
16520        // Prevent Drop from running (which would shut down the channel)
16521        std::mem::forget(self);
16522    }
16523}
16524
16525impl SocketGetIpv6ChecksumResponder {
16526    /// Sends a response to the FIDL transaction.
16527    ///
16528    /// Sets the channel to shutdown if an error occurs.
16529    pub fn send(
16530        self,
16531        mut result: Result<&Ipv6ChecksumConfiguration, fidl_fuchsia_posix::Errno>,
16532    ) -> Result<(), fidl::Error> {
16533        let _result = self.send_raw(result);
16534        if _result.is_err() {
16535            self.control_handle.shutdown();
16536        }
16537        self.drop_without_shutdown();
16538        _result
16539    }
16540
16541    /// Similar to "send" but does not shutdown the channel if an error occurs.
16542    pub fn send_no_shutdown_on_err(
16543        self,
16544        mut result: Result<&Ipv6ChecksumConfiguration, fidl_fuchsia_posix::Errno>,
16545    ) -> Result<(), fidl::Error> {
16546        let _result = self.send_raw(result);
16547        self.drop_without_shutdown();
16548        _result
16549    }
16550
16551    fn send_raw(
16552        &self,
16553        mut result: Result<&Ipv6ChecksumConfiguration, fidl_fuchsia_posix::Errno>,
16554    ) -> Result<(), fidl::Error> {
16555        self.control_handle.inner.send::<fidl::encoding::ResultType<
16556            SocketGetIpv6ChecksumResponse,
16557            fidl_fuchsia_posix::Errno,
16558        >>(
16559            result.map(|config| (config,)),
16560            self.tx_id,
16561            0x1847bf5b2d263dd,
16562            fidl::encoding::DynamicFlags::empty(),
16563        )
16564    }
16565}
16566
16567mod internal {
16568    use super::*;
16569
16570    impl fidl::encoding::ResourceTypeMarker for ProviderSocketWithOptionsResponse {
16571        type Borrowed<'a> = &'a mut Self;
16572        fn take_or_borrow<'a>(
16573            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
16574        ) -> Self::Borrowed<'a> {
16575            value
16576        }
16577    }
16578
16579    unsafe impl fidl::encoding::TypeMarker for ProviderSocketWithOptionsResponse {
16580        type Owned = Self;
16581
16582        #[inline(always)]
16583        fn inline_align(_context: fidl::encoding::Context) -> usize {
16584            4
16585        }
16586
16587        #[inline(always)]
16588        fn inline_size(_context: fidl::encoding::Context) -> usize {
16589            4
16590        }
16591    }
16592
16593    unsafe impl
16594        fidl::encoding::Encode<
16595            ProviderSocketWithOptionsResponse,
16596            fidl::encoding::DefaultFuchsiaResourceDialect,
16597        > for &mut ProviderSocketWithOptionsResponse
16598    {
16599        #[inline]
16600        unsafe fn encode(
16601            self,
16602            encoder: &mut fidl::encoding::Encoder<
16603                '_,
16604                fidl::encoding::DefaultFuchsiaResourceDialect,
16605            >,
16606            offset: usize,
16607            _depth: fidl::encoding::Depth,
16608        ) -> fidl::Result<()> {
16609            encoder.debug_check_bounds::<ProviderSocketWithOptionsResponse>(offset);
16610            // Delegate to tuple encoding.
16611            fidl::encoding::Encode::<ProviderSocketWithOptionsResponse, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
16612                (
16613                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SocketMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.s),
16614                ),
16615                encoder, offset, _depth
16616            )
16617        }
16618    }
16619    unsafe impl<
16620            T0: fidl::encoding::Encode<
16621                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SocketMarker>>,
16622                fidl::encoding::DefaultFuchsiaResourceDialect,
16623            >,
16624        >
16625        fidl::encoding::Encode<
16626            ProviderSocketWithOptionsResponse,
16627            fidl::encoding::DefaultFuchsiaResourceDialect,
16628        > for (T0,)
16629    {
16630        #[inline]
16631        unsafe fn encode(
16632            self,
16633            encoder: &mut fidl::encoding::Encoder<
16634                '_,
16635                fidl::encoding::DefaultFuchsiaResourceDialect,
16636            >,
16637            offset: usize,
16638            depth: fidl::encoding::Depth,
16639        ) -> fidl::Result<()> {
16640            encoder.debug_check_bounds::<ProviderSocketWithOptionsResponse>(offset);
16641            // Zero out padding regions. There's no need to apply masks
16642            // because the unmasked parts will be overwritten by fields.
16643            // Write the fields.
16644            self.0.encode(encoder, offset + 0, depth)?;
16645            Ok(())
16646        }
16647    }
16648
16649    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
16650        for ProviderSocketWithOptionsResponse
16651    {
16652        #[inline(always)]
16653        fn new_empty() -> Self {
16654            Self {
16655                s: fidl::new_empty!(
16656                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SocketMarker>>,
16657                    fidl::encoding::DefaultFuchsiaResourceDialect
16658                ),
16659            }
16660        }
16661
16662        #[inline]
16663        unsafe fn decode(
16664            &mut self,
16665            decoder: &mut fidl::encoding::Decoder<
16666                '_,
16667                fidl::encoding::DefaultFuchsiaResourceDialect,
16668            >,
16669            offset: usize,
16670            _depth: fidl::encoding::Depth,
16671        ) -> fidl::Result<()> {
16672            decoder.debug_check_bounds::<Self>(offset);
16673            // Verify that padding bytes are zero.
16674            fidl::decode!(
16675                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SocketMarker>>,
16676                fidl::encoding::DefaultFuchsiaResourceDialect,
16677                &mut self.s,
16678                decoder,
16679                offset + 0,
16680                _depth
16681            )?;
16682            Ok(())
16683        }
16684    }
16685
16686    impl fidl::encoding::ResourceTypeMarker for ProviderSocketResponse {
16687        type Borrowed<'a> = &'a mut Self;
16688        fn take_or_borrow<'a>(
16689            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
16690        ) -> Self::Borrowed<'a> {
16691            value
16692        }
16693    }
16694
16695    unsafe impl fidl::encoding::TypeMarker for ProviderSocketResponse {
16696        type Owned = Self;
16697
16698        #[inline(always)]
16699        fn inline_align(_context: fidl::encoding::Context) -> usize {
16700            4
16701        }
16702
16703        #[inline(always)]
16704        fn inline_size(_context: fidl::encoding::Context) -> usize {
16705            4
16706        }
16707    }
16708
16709    unsafe impl
16710        fidl::encoding::Encode<
16711            ProviderSocketResponse,
16712            fidl::encoding::DefaultFuchsiaResourceDialect,
16713        > for &mut ProviderSocketResponse
16714    {
16715        #[inline]
16716        unsafe fn encode(
16717            self,
16718            encoder: &mut fidl::encoding::Encoder<
16719                '_,
16720                fidl::encoding::DefaultFuchsiaResourceDialect,
16721            >,
16722            offset: usize,
16723            _depth: fidl::encoding::Depth,
16724        ) -> fidl::Result<()> {
16725            encoder.debug_check_bounds::<ProviderSocketResponse>(offset);
16726            // Delegate to tuple encoding.
16727            fidl::encoding::Encode::<ProviderSocketResponse, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
16728                (
16729                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SocketMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.s),
16730                ),
16731                encoder, offset, _depth
16732            )
16733        }
16734    }
16735    unsafe impl<
16736            T0: fidl::encoding::Encode<
16737                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SocketMarker>>,
16738                fidl::encoding::DefaultFuchsiaResourceDialect,
16739            >,
16740        >
16741        fidl::encoding::Encode<
16742            ProviderSocketResponse,
16743            fidl::encoding::DefaultFuchsiaResourceDialect,
16744        > for (T0,)
16745    {
16746        #[inline]
16747        unsafe fn encode(
16748            self,
16749            encoder: &mut fidl::encoding::Encoder<
16750                '_,
16751                fidl::encoding::DefaultFuchsiaResourceDialect,
16752            >,
16753            offset: usize,
16754            depth: fidl::encoding::Depth,
16755        ) -> fidl::Result<()> {
16756            encoder.debug_check_bounds::<ProviderSocketResponse>(offset);
16757            // Zero out padding regions. There's no need to apply masks
16758            // because the unmasked parts will be overwritten by fields.
16759            // Write the fields.
16760            self.0.encode(encoder, offset + 0, depth)?;
16761            Ok(())
16762        }
16763    }
16764
16765    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
16766        for ProviderSocketResponse
16767    {
16768        #[inline(always)]
16769        fn new_empty() -> Self {
16770            Self {
16771                s: fidl::new_empty!(
16772                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SocketMarker>>,
16773                    fidl::encoding::DefaultFuchsiaResourceDialect
16774                ),
16775            }
16776        }
16777
16778        #[inline]
16779        unsafe fn decode(
16780            &mut self,
16781            decoder: &mut fidl::encoding::Decoder<
16782                '_,
16783                fidl::encoding::DefaultFuchsiaResourceDialect,
16784            >,
16785            offset: usize,
16786            _depth: fidl::encoding::Depth,
16787        ) -> fidl::Result<()> {
16788            decoder.debug_check_bounds::<Self>(offset);
16789            // Verify that padding bytes are zero.
16790            fidl::decode!(
16791                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SocketMarker>>,
16792                fidl::encoding::DefaultFuchsiaResourceDialect,
16793                &mut self.s,
16794                decoder,
16795                offset + 0,
16796                _depth
16797            )?;
16798            Ok(())
16799        }
16800    }
16801
16802    impl SocketDescribeResponse {
16803        #[inline(always)]
16804        fn max_ordinal_present(&self) -> u64 {
16805            if let Some(_) = self.event {
16806                return 1;
16807            }
16808            0
16809        }
16810    }
16811
16812    impl fidl::encoding::ResourceTypeMarker for SocketDescribeResponse {
16813        type Borrowed<'a> = &'a mut Self;
16814        fn take_or_borrow<'a>(
16815            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
16816        ) -> Self::Borrowed<'a> {
16817            value
16818        }
16819    }
16820
16821    unsafe impl fidl::encoding::TypeMarker for SocketDescribeResponse {
16822        type Owned = Self;
16823
16824        #[inline(always)]
16825        fn inline_align(_context: fidl::encoding::Context) -> usize {
16826            8
16827        }
16828
16829        #[inline(always)]
16830        fn inline_size(_context: fidl::encoding::Context) -> usize {
16831            16
16832        }
16833    }
16834
16835    unsafe impl
16836        fidl::encoding::Encode<
16837            SocketDescribeResponse,
16838            fidl::encoding::DefaultFuchsiaResourceDialect,
16839        > for &mut SocketDescribeResponse
16840    {
16841        unsafe fn encode(
16842            self,
16843            encoder: &mut fidl::encoding::Encoder<
16844                '_,
16845                fidl::encoding::DefaultFuchsiaResourceDialect,
16846            >,
16847            offset: usize,
16848            mut depth: fidl::encoding::Depth,
16849        ) -> fidl::Result<()> {
16850            encoder.debug_check_bounds::<SocketDescribeResponse>(offset);
16851            // Vector header
16852            let max_ordinal: u64 = self.max_ordinal_present();
16853            encoder.write_num(max_ordinal, offset);
16854            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
16855            // Calling encoder.out_of_line_offset(0) is not allowed.
16856            if max_ordinal == 0 {
16857                return Ok(());
16858            }
16859            depth.increment()?;
16860            let envelope_size = 8;
16861            let bytes_len = max_ordinal as usize * envelope_size;
16862            #[allow(unused_variables)]
16863            let offset = encoder.out_of_line_offset(bytes_len);
16864            let mut _prev_end_offset: usize = 0;
16865            if 1 > max_ordinal {
16866                return Ok(());
16867            }
16868
16869            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
16870            // are envelope_size bytes.
16871            let cur_offset: usize = (1 - 1) * envelope_size;
16872
16873            // Zero reserved fields.
16874            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16875
16876            // Safety:
16877            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
16878            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
16879            //   envelope_size bytes, there is always sufficient room.
16880            fidl::encoding::encode_in_envelope_optional::<
16881                fidl::encoding::HandleType<
16882                    fidl::EventPair,
16883                    { fidl::ObjectType::EVENTPAIR.into_raw() },
16884                    2147483648,
16885                >,
16886                fidl::encoding::DefaultFuchsiaResourceDialect,
16887            >(
16888                self.event.as_mut().map(
16889                    <fidl::encoding::HandleType<
16890                        fidl::EventPair,
16891                        { fidl::ObjectType::EVENTPAIR.into_raw() },
16892                        2147483648,
16893                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
16894                ),
16895                encoder,
16896                offset + cur_offset,
16897                depth,
16898            )?;
16899
16900            _prev_end_offset = cur_offset + envelope_size;
16901
16902            Ok(())
16903        }
16904    }
16905
16906    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
16907        for SocketDescribeResponse
16908    {
16909        #[inline(always)]
16910        fn new_empty() -> Self {
16911            Self::default()
16912        }
16913
16914        unsafe fn decode(
16915            &mut self,
16916            decoder: &mut fidl::encoding::Decoder<
16917                '_,
16918                fidl::encoding::DefaultFuchsiaResourceDialect,
16919            >,
16920            offset: usize,
16921            mut depth: fidl::encoding::Depth,
16922        ) -> fidl::Result<()> {
16923            decoder.debug_check_bounds::<Self>(offset);
16924            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
16925                None => return Err(fidl::Error::NotNullable),
16926                Some(len) => len,
16927            };
16928            // Calling decoder.out_of_line_offset(0) is not allowed.
16929            if len == 0 {
16930                return Ok(());
16931            };
16932            depth.increment()?;
16933            let envelope_size = 8;
16934            let bytes_len = len * envelope_size;
16935            let offset = decoder.out_of_line_offset(bytes_len)?;
16936            // Decode the envelope for each type.
16937            let mut _next_ordinal_to_read = 0;
16938            let mut next_offset = offset;
16939            let end_offset = offset + bytes_len;
16940            _next_ordinal_to_read += 1;
16941            if next_offset >= end_offset {
16942                return Ok(());
16943            }
16944
16945            // Decode unknown envelopes for gaps in ordinals.
16946            while _next_ordinal_to_read < 1 {
16947                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16948                _next_ordinal_to_read += 1;
16949                next_offset += envelope_size;
16950            }
16951
16952            let next_out_of_line = decoder.next_out_of_line();
16953            let handles_before = decoder.remaining_handles();
16954            if let Some((inlined, num_bytes, num_handles)) =
16955                fidl::encoding::decode_envelope_header(decoder, next_offset)?
16956            {
16957                let member_inline_size = <fidl::encoding::HandleType<
16958                    fidl::EventPair,
16959                    { fidl::ObjectType::EVENTPAIR.into_raw() },
16960                    2147483648,
16961                > as fidl::encoding::TypeMarker>::inline_size(
16962                    decoder.context
16963                );
16964                if inlined != (member_inline_size <= 4) {
16965                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
16966                }
16967                let inner_offset;
16968                let mut inner_depth = depth.clone();
16969                if inlined {
16970                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16971                    inner_offset = next_offset;
16972                } else {
16973                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16974                    inner_depth.increment()?;
16975                }
16976                let val_ref =
16977                self.event.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
16978                fidl::decode!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
16979                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16980                {
16981                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
16982                }
16983                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16984                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16985                }
16986            }
16987
16988            next_offset += envelope_size;
16989
16990            // Decode the remaining unknown envelopes.
16991            while next_offset < end_offset {
16992                _next_ordinal_to_read += 1;
16993                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16994                next_offset += envelope_size;
16995            }
16996
16997            Ok(())
16998        }
16999    }
17000}